@kimesh/tailwindcss 0.2.49 → 0.2.50

package/dist/index.d.mts

@@ -1,3537 +1,6 @@
-import * as vite from "vite";
-import { Plugin, Plugin as VitePlugin, PluginOption, ResolvedConfig, UserConfig, ViteDevServer } from "vite";
-import MagicString from "magic-string";
+import * as _kimesh_kit0 from "@kimesh/kit";
+import { VitePlugin } from "@kimesh/kit";
 
-//#region ../../node_modules/.pnpm/hookable@6.1.0/node_modules/hookable/dist/index.d.mts
-//#region src/types.d.ts
-type HookCallback = (...arguments_: any) => Promise<void> | void;
-type HookKeys<T> = keyof T & string;
-type DeprecatedHook<T> = {
-  message?: string;
-  to: HookKeys<T>;
-};
-type ValueOf<C> = C extends Record<any, any> ? C[keyof C] : never;
-type Strings<T> = Exclude<keyof T, number | symbol>;
-type KnownKeys<T> = keyof { [K in keyof T as string extends K ? never : number extends K ? never : K]: never };
-type StripGeneric<T> = Pick<T, KnownKeys<T> extends keyof T ? KnownKeys<T> : never>;
-type OnlyGeneric<T> = Omit<T, KnownKeys<T> extends keyof T ? KnownKeys<T> : never>;
-type Namespaces<T> = ValueOf<{ [key in Strings<T>]: key extends `${infer Namespace}:${string}` ? Namespace : never }>;
-type BareHooks<T> = ValueOf<{ [key in Strings<T>]: key extends `${string}:${string}` ? never : key }>;
-type HooksInNamespace<T, Namespace extends string> = ValueOf<{ [key in Strings<T>]: key extends `${Namespace}:${infer HookName}` ? HookName : never }>;
-type WithoutNamespace<T, Namespace extends string> = { [key in HooksInNamespace<T, Namespace>]: `${Namespace}:${key}` extends keyof T ? T[`${Namespace}:${key}`] : never };
-type NestedHooks<T> = (Partial<StripGeneric<T>> | Partial<OnlyGeneric<T>>) & Partial<{ [key in Namespaces<StripGeneric<T>>]: NestedHooks<WithoutNamespace<T, key>> }> & Partial<{ [key in BareHooks<StripGeneric<T>>]: T[key] }>; //#endregion
-//#region src/hookable.d.ts
-type InferCallback<HT, HN extends keyof HT> = HT[HN] extends HookCallback ? HT[HN] : never;
-type InferSpyEvent<HT extends Record<string, any>> = { [key in keyof HT]: {
-  name: key;
-  args: Parameters<HT[key]>;
-  context: Record<string, any>;
-} }[keyof HT];
-declare class Hookable<HooksT extends Record<string, any> = Record<string, HookCallback>, HookNameT extends HookKeys<HooksT> = HookKeys<HooksT>> {
-  private _hooks;
-  private _before?;
-  private _after?;
-  private _deprecatedHooks;
-  private _deprecatedMessages?;
-  constructor();
-  hook<NameT extends HookNameT>(name: NameT, function_: InferCallback<HooksT, NameT>, options?: {
-    allowDeprecated?: boolean;
-  }): () => void;
-  hookOnce<NameT extends HookNameT>(name: NameT, function_: InferCallback<HooksT, NameT>): () => void;
-  removeHook<NameT extends HookNameT>(name: NameT, function_: InferCallback<HooksT, NameT>): void;
-  clearHook<NameT extends HookNameT>(name: NameT): void;
-  deprecateHook<NameT extends HookNameT>(name: NameT, deprecated: HookKeys<HooksT> | DeprecatedHook<HooksT>): void;
-  deprecateHooks(deprecatedHooks: Partial<Record<HookNameT, DeprecatedHook<HooksT>>>): void;
-  addHooks(configHooks: NestedHooks<HooksT>): () => void;
-  removeHooks(configHooks: NestedHooks<HooksT>): void;
-  removeAllHooks(): void;
-  callHook<NameT extends HookNameT>(name: NameT, ...args: Parameters<InferCallback<HooksT, NameT>>): Promise<any> | void;
-  callHookParallel<NameT extends HookNameT>(name: NameT, ...args: Parameters<InferCallback<HooksT, NameT>>): Promise<any[]> | void;
-  callHookWith<NameT extends HookNameT, CallFunction extends (hooks: HookCallback[], args: Parameters<InferCallback<HooksT, NameT>>, name: NameT) => any>(caller: CallFunction, name: NameT, args: Parameters<InferCallback<HooksT, NameT>>): ReturnType<CallFunction>;
-  beforeEach(function_: (event: InferSpyEvent<HooksT>) => void): () => void;
-  afterEach(function_: (event: InferSpyEvent<HooksT>) => void): () => void;
-}
-type CreateTask = (name?: string) => {
-  run: (function_: () => Promise<any> | any) => Promise<any> | any;
-};
-declare global {
-  interface Console {
-    createTask?: CreateTask;
-  }
-}
-/** @deprecated */
-//#endregion
-//#region ../../packages/layers/dist/index.d.mts
-//#region src/types.d.ts
-/**
- * @kimesh/layers - Type definitions
- *
- * This module defines the core types for the Kimesh layer system.
- */
-/**
- * Configuration for a single layer in kimesh.config.ts
- */
-interface KimeshLayerConfig {
-  /** Layer name (e.g., '@kimesh-layers/cms' or 'cms') */
-  name: string;
-  /** Path to the layer root directory */
-  path: string;
-  /** Routes configuration for this layer */
-  routes?: LayerRouteConfig;
-  /** Component configuration for this layer */
-  components?: LayerComponentConfig;
-  /** Composable configuration for this layer */
-  composables?: LayerComposableConfig;
-  /** Utils configuration for this layer */
-  utils?: LayerUtilsConfig;
-  /** Stores configuration for this layer */
-  stores?: LayerStoresConfig;
-  /** Auto-import configuration for this layer */
-  autoImport?: LayerAutoImportConfig;
-  /** CSS files to include from this layer */
-  css?: string[];
-  /** Dependencies required by this layer */
-  dependencies?: string[];
-}
-/**
- * Extended layer configuration (from `extends` array)
- * Can be a string path or full config object
- */
-/**
- * Route configuration for a layer
- */
-interface LayerRouteConfig {
-  /** Routes directory within the layer (default: 'routes') */
-  folder?: string;
-  /** Base path prefix for this layer's routes (e.g., '/blog') */
-  basePath?: string;
-  /** Include patterns for route files */
-  include?: string[];
-  /** Exclude patterns for route files */
-  exclude?: string[];
-}
-/**
- * Component configuration for a layer
- */
-interface LayerComponentConfig {
-  /** Component directories to scan */
-  dirs?: string[];
-  /** Prefix for component names (e.g., 'Cms' → CmsButton) */
-  prefix?: string | false;
-  /** Register components globally */
-  global?: boolean;
-  /** File extensions to scan */
-  extensions?: string[];
-}
-/**
- * Composable configuration for a layer
- */
-interface LayerComposableConfig {
-  /** Composable directories to scan */
-  dirs?: string[];
-  /** File extensions to scan */
-  extensions?: string[];
-}
-/**
- * Utils configuration for a layer
- */
-interface LayerUtilsConfig {
-  /** Utils directories to scan */
-  dirs?: string[];
-  /** File extensions to scan */
-  extensions?: string[];
-}
-/**
- * Stores configuration for a layer
- */
-interface LayerStoresConfig {
-  /** Stores directories to scan */
-  dirs?: string[];
-}
-/**
- * Auto-import configuration for a layer
- */
-interface LayerAutoImportConfig {
-  /** Additional imports specific to this layer */
-  imports?: Array<string | {
-    from: string;
-    imports: string[];
-  }>;
-}
-/**
- * Resolved layer with all metadata
- */
-interface ResolvedLayer {
-  /** Layer name */
-  name: string;
-  /** Absolute path to layer root */
-  path: string;
-  /** Priority (0 = app level, highest priority) */
-  priority: number;
-  /** Original configuration */
-  config: KimeshLayerConfig;
-  /** Layers this layer extends */
-  extends: string[];
-  /** Whether this is the app layer (priority 0) */
-  isApp: boolean;
-  /** Source type: 'local', 'npm', or 'workspace' */
-  source: 'local' | 'npm' | 'workspace';
-  /** Alias mappings for this layer */
-  aliases: Record<string, string>;
-  /** Runtime config from this layer's kimesh.config.ts */
-  runtimeConfig?: Record<string, unknown>;
-}
-/**
- * Layer stack - ordered list of resolved layers
- */
-//#endregion
-//#region ../../node_modules/.pnpm/esbuild@0.27.3/node_modules/esbuild/lib/main.d.ts
-// Note: These declarations exist to avoid type errors when you omit "dom" from
-// "lib" in your "tsconfig.json" file. TypeScript confusingly declares the
-// global "WebAssembly" type in "lib.dom.d.ts" even though it has nothing to do
-// with the browser DOM and is present in many non-browser JavaScript runtimes
-// (e.g. node and deno). Declaring it here allows esbuild's API to be used in
-// these scenarios.
-//
-// There's an open issue about getting this problem corrected (although these
-// declarations will need to remain even if this is fixed for backward
-// compatibility with older TypeScript versions):
-//
-//   https://github.com/microsoft/TypeScript-DOM-lib-generator/issues/826
-//
-declare global {
-  namespace WebAssembly {
-    interface Module {}
-  }
-  interface URL {}
-}
-//#endregion
-//#region ../../node_modules/.pnpm/@types+estree@1.0.8/node_modules/@types/estree/index.d.ts
-// This definition file follows a somewhat unusual format. ESTree allows
-// runtime type checks based on the `type` parameter. In order to explain this
-// to typescript we want to use discriminated union types:
-// https://github.com/Microsoft/TypeScript/pull/9163
-//
-// For ESTree this is a bit tricky because the high level interfaces like
-// Node or Function are pulling double duty. We want to pass common fields down
-// to the interfaces that extend them (like Identifier or
-// ArrowFunctionExpression), but you can't extend a type union or enforce
-// common fields on them. So we've split the high level interfaces into two
-// types, a base type which passes down inherited fields, and a type union of
-// all types which extend the base type. Only the type union is exported, and
-// the union is how other types refer to the collection of inheriting types.
-//
-// This makes the definitions file here somewhat more difficult to maintain,
-// but it has the notable advantage of making ESTree much easier to use as
-// an end user.
-interface BaseNodeWithoutComments {
-  // Every leaf interface that extends BaseNode must specify a type property.
-  // The type property should be a string literal. For example, Identifier
-  // has: `type: "Identifier"`
-  type: string;
-  loc?: SourceLocation | null | undefined;
-  range?: [number, number] | undefined;
-}
-interface BaseNode extends BaseNodeWithoutComments {
-  leadingComments?: Comment$1[] | undefined;
-  trailingComments?: Comment$1[] | undefined;
-}
-interface Comment$1 extends BaseNodeWithoutComments {
-  type: "Line" | "Block";
-  value: string;
-}
-interface SourceLocation {
-  source?: string | null | undefined;
-  start: Position;
-  end: Position;
-}
-interface Position {
-  /** >= 1 */
-  line: number;
-  /** >= 0 */
-  column: number;
-}
-interface BaseFunction extends BaseNode {
-  params: Pattern[];
-  generator?: boolean | undefined;
-  async?: boolean | undefined; // The body is either BlockStatement or Expression because arrow functions
-  // can have a body that's either. FunctionDeclarations and
-  // FunctionExpressions have only BlockStatement bodies.
-  body: BlockStatement | Expression;
-}
-type Statement = ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
-interface BaseStatement extends BaseNode {}
-interface EmptyStatement extends BaseStatement {
-  type: "EmptyStatement";
-}
-interface BlockStatement extends BaseStatement {
-  type: "BlockStatement";
-  body: Statement[];
-  innerComments?: Comment$1[] | undefined;
-}
-interface StaticBlock extends Omit<BlockStatement, "type"> {
-  type: "StaticBlock";
-}
-interface ExpressionStatement extends BaseStatement {
-  type: "ExpressionStatement";
-  expression: Expression;
-}
-interface IfStatement extends BaseStatement {
-  type: "IfStatement";
-  test: Expression;
-  consequent: Statement;
-  alternate?: Statement | null | undefined;
-}
-interface LabeledStatement extends BaseStatement {
-  type: "LabeledStatement";
-  label: Identifier;
-  body: Statement;
-}
-interface BreakStatement extends BaseStatement {
-  type: "BreakStatement";
-  label?: Identifier | null | undefined;
-}
-interface ContinueStatement extends BaseStatement {
-  type: "ContinueStatement";
-  label?: Identifier | null | undefined;
-}
-interface WithStatement extends BaseStatement {
-  type: "WithStatement";
-  object: Expression;
-  body: Statement;
-}
-interface SwitchStatement extends BaseStatement {
-  type: "SwitchStatement";
-  discriminant: Expression;
-  cases: SwitchCase[];
-}
-interface ReturnStatement extends BaseStatement {
-  type: "ReturnStatement";
-  argument?: Expression | null | undefined;
-}
-interface ThrowStatement extends BaseStatement {
-  type: "ThrowStatement";
-  argument: Expression;
-}
-interface TryStatement extends BaseStatement {
-  type: "TryStatement";
-  block: BlockStatement;
-  handler?: CatchClause | null | undefined;
-  finalizer?: BlockStatement | null | undefined;
-}
-interface WhileStatement extends BaseStatement {
-  type: "WhileStatement";
-  test: Expression;
-  body: Statement;
-}
-interface DoWhileStatement extends BaseStatement {
-  type: "DoWhileStatement";
-  body: Statement;
-  test: Expression;
-}
-interface ForStatement extends BaseStatement {
-  type: "ForStatement";
-  init?: VariableDeclaration | Expression | null | undefined;
-  test?: Expression | null | undefined;
-  update?: Expression | null | undefined;
-  body: Statement;
-}
-interface BaseForXStatement extends BaseStatement {
-  left: VariableDeclaration | Pattern;
-  right: Expression;
-  body: Statement;
-}
-interface ForInStatement extends BaseForXStatement {
-  type: "ForInStatement";
-}
-interface DebuggerStatement extends BaseStatement {
-  type: "DebuggerStatement";
-}
-type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
-interface BaseDeclaration extends BaseStatement {}
-interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
-  type: "FunctionDeclaration";
-  /** It is null when a function declaration is a part of the `export default function` statement */
-  id: Identifier | null;
-  body: BlockStatement;
-}
-interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
-  id: Identifier;
-}
-interface VariableDeclaration extends BaseDeclaration {
-  type: "VariableDeclaration";
-  declarations: VariableDeclarator[];
-  kind: "var" | "let" | "const" | "using" | "await using";
-}
-interface VariableDeclarator extends BaseNode {
-  type: "VariableDeclarator";
-  id: Pattern;
-  init?: Expression | null | undefined;
-}
-interface ExpressionMap {
-  ArrayExpression: ArrayExpression;
-  ArrowFunctionExpression: ArrowFunctionExpression;
-  AssignmentExpression: AssignmentExpression;
-  AwaitExpression: AwaitExpression;
-  BinaryExpression: BinaryExpression;
-  CallExpression: CallExpression;
-  ChainExpression: ChainExpression;
-  ClassExpression: ClassExpression;
-  ConditionalExpression: ConditionalExpression;
-  FunctionExpression: FunctionExpression;
-  Identifier: Identifier;
-  ImportExpression: ImportExpression;
-  Literal: Literal;
-  LogicalExpression: LogicalExpression;
-  MemberExpression: MemberExpression;
-  MetaProperty: MetaProperty;
-  NewExpression: NewExpression;
-  ObjectExpression: ObjectExpression;
-  SequenceExpression: SequenceExpression;
-  TaggedTemplateExpression: TaggedTemplateExpression;
-  TemplateLiteral: TemplateLiteral;
-  ThisExpression: ThisExpression;
-  UnaryExpression: UnaryExpression;
-  UpdateExpression: UpdateExpression;
-  YieldExpression: YieldExpression;
-}
-type Expression = ExpressionMap[keyof ExpressionMap];
-interface BaseExpression extends BaseNode {}
-type ChainElement = SimpleCallExpression | MemberExpression;
-interface ChainExpression extends BaseExpression {
-  type: "ChainExpression";
-  expression: ChainElement;
-}
-interface ThisExpression extends BaseExpression {
-  type: "ThisExpression";
-}
-interface ArrayExpression extends BaseExpression {
-  type: "ArrayExpression";
-  elements: Array<Expression | SpreadElement | null>;
-}
-interface ObjectExpression extends BaseExpression {
-  type: "ObjectExpression";
-  properties: Array<Property | SpreadElement>;
-}
-interface PrivateIdentifier extends BaseNode {
-  type: "PrivateIdentifier";
-  name: string;
-}
-interface Property extends BaseNode {
-  type: "Property";
-  key: Expression | PrivateIdentifier;
-  value: Expression | Pattern; // Could be an AssignmentProperty
-  kind: "init" | "get" | "set";
-  method: boolean;
-  shorthand: boolean;
-  computed: boolean;
-}
-interface PropertyDefinition extends BaseNode {
-  type: "PropertyDefinition";
-  key: Expression | PrivateIdentifier;
-  value?: Expression | null | undefined;
-  computed: boolean;
-  static: boolean;
-}
-interface FunctionExpression extends BaseFunction, BaseExpression {
-  id?: Identifier | null | undefined;
-  type: "FunctionExpression";
-  body: BlockStatement;
-}
-interface SequenceExpression extends BaseExpression {
-  type: "SequenceExpression";
-  expressions: Expression[];
-}
-interface UnaryExpression extends BaseExpression {
-  type: "UnaryExpression";
-  operator: UnaryOperator;
-  prefix: true;
-  argument: Expression;
-}
-interface BinaryExpression extends BaseExpression {
-  type: "BinaryExpression";
-  operator: BinaryOperator;
-  left: Expression | PrivateIdentifier;
-  right: Expression;
-}
-interface AssignmentExpression extends BaseExpression {
-  type: "AssignmentExpression";
-  operator: AssignmentOperator;
-  left: Pattern | MemberExpression;
-  right: Expression;
-}
-interface UpdateExpression extends BaseExpression {
-  type: "UpdateExpression";
-  operator: UpdateOperator;
-  argument: Expression;
-  prefix: boolean;
-}
-interface LogicalExpression extends BaseExpression {
-  type: "LogicalExpression";
-  operator: LogicalOperator;
-  left: Expression;
-  right: Expression;
-}
-interface ConditionalExpression extends BaseExpression {
-  type: "ConditionalExpression";
-  test: Expression;
-  alternate: Expression;
-  consequent: Expression;
-}
-interface BaseCallExpression extends BaseExpression {
-  callee: Expression | Super;
-  arguments: Array<Expression | SpreadElement>;
-}
-type CallExpression = SimpleCallExpression | NewExpression;
-interface SimpleCallExpression extends BaseCallExpression {
-  type: "CallExpression";
-  optional: boolean;
-}
-interface NewExpression extends BaseCallExpression {
-  type: "NewExpression";
-}
-interface MemberExpression extends BaseExpression, BasePattern {
-  type: "MemberExpression";
-  object: Expression | Super;
-  property: Expression | PrivateIdentifier;
-  computed: boolean;
-  optional: boolean;
-}
-type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
-interface BasePattern extends BaseNode {}
-interface SwitchCase extends BaseNode {
-  type: "SwitchCase";
-  test?: Expression | null | undefined;
-  consequent: Statement[];
-}
-interface CatchClause extends BaseNode {
-  type: "CatchClause";
-  param: Pattern | null;
-  body: BlockStatement;
-}
-interface Identifier extends BaseNode, BaseExpression, BasePattern {
-  type: "Identifier";
-  name: string;
-}
-type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
-interface SimpleLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value: string | boolean | number | null;
-  raw?: string | undefined;
-}
-interface RegExpLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value?: RegExp | null | undefined;
-  regex: {
-    pattern: string;
-    flags: string;
-  };
-  raw?: string | undefined;
-}
-interface BigIntLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value?: bigint | null | undefined;
-  bigint: string;
-  raw?: string | undefined;
-}
-type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
-type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
-type LogicalOperator = "||" | "&&" | "??";
-type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
-type UpdateOperator = "++" | "--";
-interface ForOfStatement extends BaseForXStatement {
-  type: "ForOfStatement";
-  await: boolean;
-}
-interface Super extends BaseNode {
-  type: "Super";
-}
-interface SpreadElement extends BaseNode {
-  type: "SpreadElement";
-  argument: Expression;
-}
-interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
-  type: "ArrowFunctionExpression";
-  expression: boolean;
-  body: BlockStatement | Expression;
-}
-interface YieldExpression extends BaseExpression {
-  type: "YieldExpression";
-  argument?: Expression | null | undefined;
-  delegate: boolean;
-}
-interface TemplateLiteral extends BaseExpression {
-  type: "TemplateLiteral";
-  quasis: TemplateElement[];
-  expressions: Expression[];
-}
-interface TaggedTemplateExpression extends BaseExpression {
-  type: "TaggedTemplateExpression";
-  tag: Expression;
-  quasi: TemplateLiteral;
-}
-interface TemplateElement extends BaseNode {
-  type: "TemplateElement";
-  tail: boolean;
-  value: {
-    /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */cooked?: string | null | undefined;
-    raw: string;
-  };
-}
-interface AssignmentProperty extends Property {
-  value: Pattern;
-  kind: "init";
-  method: boolean; // false
-}
-interface ObjectPattern extends BasePattern {
-  type: "ObjectPattern";
-  properties: Array<AssignmentProperty | RestElement>;
-}
-interface ArrayPattern extends BasePattern {
-  type: "ArrayPattern";
-  elements: Array<Pattern | null>;
-}
-interface RestElement extends BasePattern {
-  type: "RestElement";
-  argument: Pattern;
-}
-interface AssignmentPattern extends BasePattern {
-  type: "AssignmentPattern";
-  left: Pattern;
-  right: Expression;
-}
-interface BaseClass extends BaseNode {
-  superClass?: Expression | null | undefined;
-  body: ClassBody;
-}
-interface ClassBody extends BaseNode {
-  type: "ClassBody";
-  body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
-}
-interface MethodDefinition extends BaseNode {
-  type: "MethodDefinition";
-  key: Expression | PrivateIdentifier;
-  value: FunctionExpression;
-  kind: "constructor" | "method" | "get" | "set";
-  computed: boolean;
-  static: boolean;
-}
-interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
-  type: "ClassDeclaration";
-  /** It is null when a class declaration is a part of the `export default class` statement */
-  id: Identifier | null;
-}
-interface ClassDeclaration extends MaybeNamedClassDeclaration {
-  id: Identifier;
-}
-interface ClassExpression extends BaseClass, BaseExpression {
-  type: "ClassExpression";
-  id?: Identifier | null | undefined;
-}
-interface MetaProperty extends BaseExpression {
-  type: "MetaProperty";
-  meta: Identifier;
-  property: Identifier;
-}
-interface ImportExpression extends BaseExpression {
-  type: "ImportExpression";
-  source: Expression;
-  options?: Expression | null | undefined;
-}
-interface AwaitExpression extends BaseExpression {
-  type: "AwaitExpression";
-  argument: Expression;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/rollup@4.59.0/node_modules/rollup/dist/rollup.d.ts
-declare module 'estree' {
-  export interface Decorator extends BaseNode {
-    type: 'Decorator';
-    expression: Expression;
-  }
-  interface PropertyDefinition {
-    decorators: undefined[];
-  }
-  interface MethodDefinition {
-    decorators: undefined[];
-  }
-  interface BaseClass {
-    decorators: undefined[];
-  }
-}
-// declare AbortSignal here for environments without DOM lib or @types/node
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-  interface AbortSignal {}
-}
-//#endregion
-//#region ../../node_modules/.pnpm/unplugin-vue-components@31.0.0_vue@3.5.29_typescript@5.9.3_/node_modules/unplugin-vue-components/dist/types-CWfK8m_y.d.mts
-//#region node_modules/.pnpm/@antfu+utils@9.3.0/node_modules/@antfu/utils/dist/index.d.mts
-/**
- * Promise, or maybe not
- */
-type Awaitable<T> = T | PromiseLike<T>;
-/**
- * Null or whatever
- */
-//#endregion
-//#region src/types.d.ts
-interface ImportInfo {
-  as?: string;
-  name?: string;
-  from: string;
-}
-type SideEffectsInfo = (ImportInfo | string)[] | ImportInfo | string | undefined;
-interface ComponentInfo extends ImportInfo {
-  sideEffects?: SideEffectsInfo;
-}
-type ComponentResolveResult = Awaitable<string | ComponentInfo | null | undefined | void>;
-type ComponentResolverFunction = (name: string) => ComponentResolveResult;
-interface ComponentResolverObject {
-  type: 'component' | 'directive';
-  resolve: ComponentResolverFunction;
-}
-type ComponentResolver = ComponentResolverFunction | ComponentResolverObject;
-//#endregion
-//#region ../../node_modules/.pnpm/@vue+shared@3.5.29/node_modules/@vue/shared/dist/shared.d.ts
-type Prettify<T> = { [K in keyof T]: T[K] } & {};
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
-type LooseRequired<T> = { [P in keyof (T & Required<T>)]: T[P] };
-type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
-//#endregion
-//#region ../../node_modules/.pnpm/@vue+reactivity@3.5.29/node_modules/@vue/reactivity/dist/reactivity.d.ts
-declare enum TrackOpTypes {
-  GET = "get",
-  HAS = "has",
-  ITERATE = "iterate"
-}
-declare enum TriggerOpTypes {
-  SET = "set",
-  ADD = "add",
-  DELETE = "delete",
-  CLEAR = "clear"
-}
-type UnwrapNestedRefs<T> = T extends Ref ? T : UnwrapRefSimple<T>;
-declare const ShallowReactiveMarker: unique symbol;
-type Primitive = string | number | boolean | bigint | symbol | undefined | null;
-type Builtin = Primitive | Function | Date | Error | RegExp;
-type EffectScheduler = (...args: any[]) => any;
-type DebuggerEvent = {
-  effect: Subscriber;
-} & DebuggerEventExtraInfo;
-type DebuggerEventExtraInfo = {
-  target: object;
-  type: TrackOpTypes | TriggerOpTypes;
-  key: any;
-  newValue?: any;
-  oldValue?: any;
-  oldTarget?: Map<any, any> | Set<any>;
-};
-interface DebuggerOptions {
-  onTrack?: (event: DebuggerEvent) => void;
-  onTrigger?: (event: DebuggerEvent) => void;
-}
-interface ReactiveEffectOptions extends DebuggerOptions {
-  scheduler?: EffectScheduler;
-  allowRecurse?: boolean;
-  onStop?: () => void;
-}
-/**
- * Subscriber is a type that tracks (or subscribes to) a list of deps.
- */
-interface Subscriber extends DebuggerOptions {}
-declare class ReactiveEffect<T = any> implements Subscriber, ReactiveEffectOptions {
-  fn: () => T;
-  scheduler?: EffectScheduler;
-  onStop?: () => void;
-  onTrack?: (event: DebuggerEvent) => void;
-  onTrigger?: (event: DebuggerEvent) => void;
-  constructor(fn: () => T);
-  pause(): void;
-  resume(): void;
-  run(): T;
-  stop(): void;
-  trigger(): void;
-  get dirty(): boolean;
-}
-type ComputedGetter<T> = (oldValue?: T) => T;
-type ComputedSetter<T> = (newValue: T) => void;
-interface WritableComputedOptions<T, S = T> {
-  get: ComputedGetter<T>;
-  set: ComputedSetter<S>;
-}
-declare const RefSymbol: unique symbol;
-declare const RawSymbol: unique symbol;
-interface Ref<T = any, S = T> {
-  get value(): T;
-  set value(_: S);
-  /**
-   * Type differentiator only.
-   * We need this to be in public d.ts but don't want it to show up in IDE
-   * autocomplete, so we use a private Symbol instead.
-   */
-  [RefSymbol]: true;
-}
-declare const ShallowRefMarker: unique symbol;
-type ShallowRef<T = any, S = T> = Ref<T, S> & {
-  [ShallowRefMarker]?: true;
-};
-/**
- * This is a special exported interface for other packages to declare
- * additional types that should bail out for ref unwrapping. For example
- * \@vue/runtime-dom can declare it like so in its d.ts:
- *
- * ``` ts
- * declare module '@vue/reactivity' {
- *   export interface RefUnwrapBailTypes {
- *     runtimeDOMBailTypes: Node | Window
- *   }
- * }
- * ```
- */
-interface RefUnwrapBailTypes {}
-type ShallowUnwrapRef<T> = { [K in keyof T]: DistributeRef<T[K]> };
-type DistributeRef<T> = T extends Ref<infer V, unknown> ? V : T;
-type UnwrapRef<T> = T extends ShallowRef<infer V, unknown> ? V : T extends Ref<infer V, unknown> ? UnwrapRefSimple<V> : UnwrapRefSimple<T>;
-type UnwrapRefSimple<T> = T extends Builtin | Ref | RefUnwrapBailTypes[keyof RefUnwrapBailTypes] | {
-  [RawSymbol]?: true;
-} ? T : T extends Map<infer K, infer V> ? Map<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Map<any, any>>> : T extends WeakMap<infer K, infer V> ? WeakMap<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakMap<any, any>>> : T extends Set<infer V> ? Set<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Set<any>>> : T extends WeakSet<infer V> ? WeakSet<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakSet<any>>> : T extends ReadonlyArray<any> ? { [K in keyof T]: UnwrapRefSimple<T[K]> } : T extends object & {
-  [ShallowReactiveMarker]?: never;
-} ? { [P in keyof T]: P extends symbol ? T[P] : UnwrapRef<T[P]> } : T;
-type WatchCallback<V = any, OV = any> = (value: V, oldValue: OV, onCleanup: OnCleanup) => any;
-type OnCleanup = (cleanupFn: () => void) => void;
-type WatchStopHandle = () => void;
-//#endregion
-//#region ../../node_modules/.pnpm/@vue+runtime-core@3.5.29/node_modules/@vue/runtime-core/dist/runtime-core.d.ts
-type Slot<T extends any = any> = (...args: IfAny<T, any[], [T] | (T extends undefined ? [] : never)>) => VNode[];
-type InternalSlots = {
-  [name: string]: Slot | undefined;
-};
-type Slots = Readonly<InternalSlots>;
-declare const SlotSymbol: unique symbol;
-type SlotsType<T extends Record<string, any> = Record<string, any>> = {
-  [SlotSymbol]?: T;
-};
-type StrictUnwrapSlotsType<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<T> & T;
-type UnwrapSlotsType<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<Prettify<{ [K in keyof T]: NonNullable<T[K]> extends ((...args: any[]) => any) ? T[K] : Slot<T[K]> }>>;
-type RawSlots = {
-  [name: string]: unknown;
-  $stable?: boolean;
-};
-declare enum SchedulerJobFlags {
-  QUEUED = 1,
-  PRE = 2,
-  /**
-   * Indicates whether the effect is allowed to recursively trigger itself
-   * when managed by the scheduler.
-   *
-   * By default, a job cannot trigger itself because some built-in method calls,
-   * e.g. Array.prototype.push actually performs reads as well (#1740) which
-   * can lead to confusing infinite loops.
-   * The allowed cases are component update functions and watch callbacks.
-   * Component update functions may update child component props, which in turn
-   * trigger flush: "pre" watch callbacks that mutates state that the parent
-   * relies on (#1801). Watch callbacks doesn't track its dependencies so if it
-   * triggers itself again, it's likely intentional and it is the user's
-   * responsibility to perform recursive state mutation that eventually
-   * stabilizes (#1727).
-   */
-  ALLOW_RECURSE = 4,
-  DISPOSED = 8
-}
-interface SchedulerJob extends Function {
-  id?: number;
-  /**
-   * flags can technically be undefined, but it can still be used in bitwise
-   * operations just like 0.
-   */
-  flags?: SchedulerJobFlags;
-  /**
-   * Attached by renderer.ts when setting up a component's render effect
-   * Used to obtain component information when reporting max recursive updates.
-   */
-  i?: ComponentInternalInstance;
-}
-declare function nextTick(): Promise<void>;
-declare function nextTick<T, R>(this: T, fn: (this: T) => R | Promise<R>): Promise<R>;
-type ComponentPropsOptions<P = Data> = ComponentObjectPropsOptions<P> | string[];
-type ComponentObjectPropsOptions<P = Data> = { [K in keyof P]: Prop<P[K]> | null };
-type Prop<T, D = T> = PropOptions<T, D> | PropType<T>;
-type DefaultFactory<T> = (props: Data) => T | null | undefined;
-interface PropOptions<T = any, D = T> {
-  type?: PropType<T> | true | null;
-  required?: boolean;
-  default?: D | DefaultFactory<D> | null | undefined | object;
-  validator?(value: unknown, props: Data): boolean;
-}
-type PropType<T> = PropConstructor<T> | (PropConstructor<T> | null)[];
-type PropConstructor<T = any> = {
-  new (...args: any[]): T & {};
-} | {
-  (): T;
-} | PropMethod<T>;
-type PropMethod<T, TConstructor = any> = [T] extends [((...args: any) => any) | undefined] ? {
-  new (): TConstructor;
-  (): T;
-  readonly prototype: TConstructor;
-} : never;
-type RequiredKeys<T> = { [K in keyof T]: T[K] extends {
-  required: true;
-} | {
-  default: any;
-} | BooleanConstructor | {
-  type: BooleanConstructor;
-} ? T[K] extends {
-  default: undefined | (() => undefined);
-} ? never : K : never }[keyof T];
-type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
-type DefaultKeys<T> = { [K in keyof T]: T[K] extends {
-  default: any;
-} | BooleanConstructor | {
-  type: BooleanConstructor;
-} ? T[K] extends {
-  type: BooleanConstructor;
-  required: true;
-} ? never : K : never }[keyof T];
-type InferPropType<T, NullAsAny = true> = [T] extends [null] ? NullAsAny extends true ? any : null : [T] extends [{
-  type: null | true;
-}] ? any : [T] extends [ObjectConstructor | {
-  type: ObjectConstructor;
-}] ? Record<string, any> : [T] extends [BooleanConstructor | {
-  type: BooleanConstructor;
-}] ? boolean : [T] extends [DateConstructor | {
-  type: DateConstructor;
-}] ? Date : [T] extends [(infer U)[] | {
-  type: (infer U)[];
-}] ? U extends DateConstructor ? Date | InferPropType<U, false> : InferPropType<U, false> : [T] extends [Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? IfAny<V, V, D> : V : V : T;
-/**
- * Extract prop types from a runtime props options object.
- * The extracted types are **internal** - i.e. the resolved props received by
- * the component.
- * - Boolean props are always present
- * - Props with default values are always present
- *
- * To extract accepted props from the parent, use {@link ExtractPublicPropTypes}.
- */
-type ExtractPropTypes<O> = { [K in keyof Pick<O, RequiredKeys<O>>]: O[K] extends {
-  default: any;
-} ? Exclude<InferPropType<O[K]>, undefined> : InferPropType<O[K]> } & { [K in keyof Pick<O, OptionalKeys<O>>]?: InferPropType<O[K]> };
-type ExtractDefaultPropTypes<O> = O extends object ? { [K in keyof Pick<O, DefaultKeys<O>>]: InferPropType<O[K]> } : {};
-/**
- * Vue `<script setup>` compiler macro for declaring component props. The
- * expected argument is the same as the component `props` option.
- *
- * Example runtime declaration:
- * ```js
- * // using Array syntax
- * const props = defineProps(['foo', 'bar'])
- * // using Object syntax
- * const props = defineProps({
- *   foo: String,
- *   bar: {
- *     type: Number,
- *     required: true
- *   }
- * })
- * ```
- *
- * Equivalent type-based declaration:
- * ```ts
- * // will be compiled into equivalent runtime declarations
- * const props = defineProps<{
- *   foo?: string
- *   bar: number
- * }>()
- * ```
- *
- * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineprops-defineemits}
- *
- * This is only usable inside `<script setup>`, is compiled away in the
- * output and should **not** be actually called at runtime.
- */
-declare function defineProps<PropNames extends string = string>(props: PropNames[]): Prettify<Readonly<{ [key in PropNames]?: any }>>;
-declare function defineProps<PP extends ComponentObjectPropsOptions = ComponentObjectPropsOptions>(props: PP): Prettify<Readonly<ExtractPropTypes<PP>>>;
-declare function defineProps<TypeProps>(): DefineProps<LooseRequired<TypeProps>, BooleanKey<TypeProps>>;
-type DefineProps<T, BKeys extends keyof T> = Readonly<T> & { readonly [K in BKeys]-?: boolean };
-type BooleanKey<T, K extends keyof T = keyof T> = K extends any ? T[K] extends boolean | undefined ? T[K] extends never | undefined ? never : K : never : never;
-/**
- * Vue `<script setup>` compiler macro for declaring a component's emitted
- * events. The expected argument is the same as the component `emits` option.
- *
- * Example runtime declaration:
- * ```js
- * const emit = defineEmits(['change', 'update'])
- * ```
- *
- * Example type-based declaration:
- * ```ts
- * const emit = defineEmits<{
- *   // <eventName>: <expected arguments>
- *   change: []
- *   update: [value: number] // named tuple syntax
- * }>()
- *
- * emit('change')
- * emit('update', 1)
- * ```
- *
- * This is only usable inside `<script setup>`, is compiled away in the
- * output and should **not** be actually called at runtime.
- *
- * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineprops-defineemits}
- */
-declare function defineEmits<EE extends string = string>(emitOptions: EE[]): EmitFn<EE[]>;
-declare function defineEmits<E extends EmitsOptions = EmitsOptions>(emitOptions: E): EmitFn<E>;
-declare function defineEmits<T extends ComponentTypeEmits>(): T extends ((...args: any[]) => any) ? T : ShortEmits<T>;
-type ComponentTypeEmits = ((...args: any[]) => any) | Record<string, any>;
-type RecordToUnion<T extends Record<string, any>> = T[keyof T];
-type ShortEmits<T extends Record<string, any>> = UnionToIntersection<RecordToUnion<{ [K in keyof T]: (evt: K, ...args: T[K]) => void }>>;
-/**
- * Vue `<script setup>` compiler macro for declaring a component's exposed
- * instance properties when it is accessed by a parent component via template
- * refs.
- *
- * `<script setup>` components are closed by default - i.e. variables inside
- * the `<script setup>` scope is not exposed to parent unless explicitly exposed
- * via `defineExpose`.
- *
- * This is only usable inside `<script setup>`, is compiled away in the
- * output and should **not** be actually called at runtime.
- *
- * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineexpose}
- */
-declare function defineExpose<Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed): void;
-/**
- * Vue `<script setup>` compiler macro for declaring a component's additional
- * options. This should be used only for options that cannot be expressed via
- * Composition API - e.g. `inheritAttrs`.
- *
- * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineoptions}
- */
-declare function defineOptions<RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin>(options?: ComponentOptionsBase<{}, RawBindings, D, C, M, Mixin, Extends, {}> & {
-  /**
-   * props should be defined via defineProps().
-   */
-  props?: never;
-  /**
-   * emits should be defined via defineEmits().
-   */
-  emits?: never;
-  /**
-   * expose should be defined via defineExpose().
-   */
-  expose?: never;
-  /**
-   * slots should be defined via defineSlots().
-   */
-  slots?: never;
-}): void;
-declare function defineSlots<S extends Record<string, any> = Record<string, any>>(): StrictUnwrapSlotsType<SlotsType<S>>;
-type ModelRef<T, M extends PropertyKey = string, G = T, S = T> = Ref<G, S> & [ModelRef<T, M, G, S>, Record<M, true | undefined>];
-type DefineModelOptions<T = any, G = T, S = T> = {
-  get?: (v: T) => G;
-  set?: (v: S) => any;
-};
-/**
- * Vue `<script setup>` compiler macro for declaring a
- * two-way binding prop that can be consumed via `v-model` from the parent
- * component. This will declare a prop with the same name and a corresponding
- * `update:propName` event.
- *
- * If the first argument is a string, it will be used as the prop name;
- * Otherwise the prop name will default to "modelValue". In both cases, you
- * can also pass an additional object which will be used as the prop's options.
- *
- * The returned ref behaves differently depending on whether the parent
- * provided the corresponding v-model props or not:
- * - If yes, the returned ref's value will always be in sync with the parent
- *   prop.
- * - If not, the returned ref will behave like a normal local ref.
- *
- * @example
- * ```ts
- * // default model (consumed via `v-model`)
- * const modelValue = defineModel<string>()
- * modelValue.value = "hello"
- *
- * // default model with options
- * const modelValue = defineModel<string>({ required: true })
- *
- * // with specified name (consumed via `v-model:count`)
- * const count = defineModel<number>('count')
- * count.value++
- *
- * // with specified name and default value
- * const count = defineModel<number>('count', { default: 0 })
- * ```
- */
-declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(options: ({
-  default: any;
-} | {
-  required: true;
-}) & PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T, M, G, S>;
-declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(options?: PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T | undefined, M, G | undefined, S | undefined>;
-declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(name: string, options: ({
-  default: any;
-} | {
-  required: true;
-}) & PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T, M, G, S>;
-declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(name: string, options?: PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T | undefined, M, G | undefined, S | undefined>;
-type NotUndefined<T> = T extends undefined ? never : T;
-type MappedOmit<T, K extends keyof any> = { [P in keyof T as P extends K ? never : P]: T[P] };
-type InferDefaults<T> = { [K in keyof T]?: InferDefault<T, T[K]> };
-type NativeType = null | undefined | number | string | boolean | symbol | Function;
-type InferDefault<P, T> = ((props: P) => T & {}) | (T extends NativeType ? T : never);
-type PropsWithDefaults<T, Defaults extends InferDefaults<T>, BKeys extends keyof T> = T extends unknown ? Readonly<MappedOmit<T, keyof Defaults>> & { readonly [K in keyof Defaults as K extends keyof T ? K : never]-?: K extends keyof T ? Defaults[K] extends undefined ? IfAny<Defaults[K], NotUndefined<T[K]>, T[K]> : NotUndefined<T[K]> : never } & { readonly [K in BKeys]-?: K extends keyof Defaults ? Defaults[K] extends undefined ? boolean | undefined : boolean : boolean } : never;
-/**
- * Vue `<script setup>` compiler macro for providing props default values when
- * using type-based `defineProps` declaration.
- *
- * Example usage:
- * ```ts
- * withDefaults(defineProps<{
- *   size?: number
- *   labels?: string[]
- * }>(), {
- *   size: 3,
- *   labels: () => ['default label']
- * })
- * ```
- *
- * This is only usable inside `<script setup>`, is compiled away in the output
- * and should **not** be actually called at runtime.
- *
- * @see {@link https://vuejs.org/guide/typescript/composition-api.html#typing-component-props}
- */
-declare function withDefaults<T, BKeys extends keyof T, Defaults extends InferDefaults<T>>(props: DefineProps<T, BKeys>, defaults: Defaults): PropsWithDefaults<T, Defaults, BKeys>;
-type ObjectEmitsOptions = Record<string, ((...args: any[]) => any) | null>;
-type EmitsOptions = ObjectEmitsOptions | string[];
-type EmitsToProps<T extends EmitsOptions | ComponentTypeEmits> = T extends string[] ? { [K in `on${Capitalize<T[number]>}`]?: (...args: any[]) => any } : T extends ObjectEmitsOptions ? { [K in string & keyof T as `on${Capitalize<K>}`]?: (...args: T[K] extends ((...args: infer P) => any) ? P : T[K] extends null ? any[] : never) => any } : {};
-type ShortEmitsToObject<E> = E extends Record<string, any[]> ? { [K in keyof E]: (...args: E[K]) => any } : E;
-type EmitFn<Options = ObjectEmitsOptions, Event extends keyof Options = keyof Options> = Options extends Array<infer V> ? (event: V, ...args: any[]) => void : {} extends Options ? (event: string, ...args: any[]) => void : UnionToIntersection<{ [key in Event]: Options[key] extends ((...args: infer Args) => any) ? (event: key, ...args: Args) => void : Options[key] extends any[] ? (event: key, ...args: Options[key]) => void : (event: key, ...args: any[]) => void }[Event]>;
-/**
-Runtime helper for applying directives to a vnode. Example usage:
-
-const comp = resolveComponent('comp')
-const foo = resolveDirective('foo')
-const bar = resolveDirective('bar')
-
-return withDirectives(h(comp), [
-  [foo, this.x],
-  [bar, this.y]
-])
-*/
-interface DirectiveBinding<Value = any, Modifiers extends string = string, Arg = any> {
-  instance: ComponentPublicInstance | Record<string, any> | null;
-  value: Value;
-  oldValue: Value | null;
-  arg?: Arg;
-  modifiers: DirectiveModifiers<Modifiers>;
-  dir: ObjectDirective<any, Value, Modifiers, Arg>;
-}
-type DirectiveHook<HostElement = any, Prev = VNode<any, HostElement> | null, Value = any, Modifiers extends string = string, Arg = any> = (el: HostElement, binding: DirectiveBinding<Value, Modifiers, Arg>, vnode: VNode<any, HostElement>, prevVNode: Prev) => void;
-type SSRDirectiveHook<Value = any, Modifiers extends string = string, Arg = any> = (binding: DirectiveBinding<Value, Modifiers, Arg>, vnode: VNode) => Data | undefined;
-interface ObjectDirective<HostElement = any, Value = any, Modifiers extends string = string, Arg = any> {
-  created?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
-  beforeMount?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
-  mounted?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
-  beforeUpdate?: DirectiveHook<HostElement, VNode<any, HostElement>, Value, Modifiers, Arg>;
-  updated?: DirectiveHook<HostElement, VNode<any, HostElement>, Value, Modifiers, Arg>;
-  beforeUnmount?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
-  unmounted?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
-  getSSRProps?: SSRDirectiveHook<Value, Modifiers, Arg>;
-  deep?: boolean;
-}
-type FunctionDirective<HostElement = any, V = any, Modifiers extends string = string, Arg = any> = DirectiveHook<HostElement, any, V, Modifiers, Arg>;
-type Directive<HostElement = any, Value = any, Modifiers extends string = string, Arg = any> = ObjectDirective<HostElement, Value, Modifiers, Arg> | FunctionDirective<HostElement, Value, Modifiers, Arg>;
-type DirectiveModifiers<K extends string = string> = Partial<Record<K, boolean>>;
-/**
- * Custom properties added to component instances in any way and can be accessed through `this`
- *
- * @example
- * Here is an example of adding a property `$router` to every component instance:
- * ```ts
- * import { createApp } from 'vue'
- * import { Router, createRouter } from 'vue-router'
- *
- * declare module 'vue' {
- *   interface ComponentCustomProperties {
- *     $router: Router
- *   }
- * }
- *
- * // effectively adding the router to every component instance
- * const app = createApp({})
- * const router = createRouter()
- * app.config.globalProperties.$router = router
- *
- * const vm = app.mount('#app')
- * // we can access the router from the instance
- * vm.$router.push('/')
- * ```
- */
-interface ComponentCustomProperties {}
-type IsDefaultMixinComponent<T> = T extends ComponentOptionsMixin ? ComponentOptionsMixin extends T ? true : false : false;
-type MixinToOptionTypes<T> = T extends ComponentOptionsBase<infer P, infer B, infer D, infer C, infer M, infer Mixin, infer Extends, any, any, infer Defaults, any, any, any, any, any, any, any> ? OptionTypesType<P & {}, B & {}, D & {}, C & {}, M & {}, Defaults & {}> & IntersectionMixin<Mixin> & IntersectionMixin<Extends> : never;
-type ExtractMixin<T> = {
-  Mixin: MixinToOptionTypes<T>;
-}[T extends ComponentOptionsMixin ? 'Mixin' : never];
-type IntersectionMixin<T> = IsDefaultMixinComponent<T> extends true ? OptionTypesType : UnionToIntersection<ExtractMixin<T>>;
-type UnwrapMixinsType<T, Type extends OptionTypesKeys> = T extends OptionTypesType ? T[Type] : never;
-type EnsureNonVoid<T> = T extends void ? {} : T;
-type ComponentPublicInstanceConstructor<T extends ComponentPublicInstance<Props, RawBindings, D, C, M> = ComponentPublicInstance<any>, Props = any, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions> = {
-  __isFragment?: never;
-  __isTeleport?: never;
-  __isSuspense?: never;
-  new (...args: any[]): T;
-};
-/**
- * @deprecated This is no longer used internally, but exported and relied on by
- * existing library types generated by vue-tsc.
- */
-/**
- * This is the same as `CreateComponentPublicInstance` but adds local components,
- * global directives, exposed, and provide inference.
- * It changes the arguments order so that we don't need to repeat mixin
- * inference everywhere internally, but it has to be a new type to avoid
- * breaking types that relies on previous arguments order (#10842)
- */
-type CreateComponentPublicInstanceWithMixins<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, PublicProps = P, Defaults = {}, MakeDefaultsOptional extends boolean = false, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, TypeRefs extends Data = {}, TypeEl extends Element = any, Provide extends ComponentProvideOptions = ComponentProvideOptions, PublicMixin = IntersectionMixin<Mixin> & IntersectionMixin<Extends>, PublicP = UnwrapMixinsType<PublicMixin, 'P'> & EnsureNonVoid<P>, PublicB = UnwrapMixinsType<PublicMixin, 'B'> & EnsureNonVoid<B>, PublicD = UnwrapMixinsType<PublicMixin, 'D'> & EnsureNonVoid<D>, PublicC extends ComputedOptions = UnwrapMixinsType<PublicMixin, 'C'> & EnsureNonVoid<C>, PublicM extends MethodOptions = UnwrapMixinsType<PublicMixin, 'M'> & EnsureNonVoid<M>, PublicDefaults = UnwrapMixinsType<PublicMixin, 'Defaults'> & EnsureNonVoid<Defaults>> = ComponentPublicInstance<PublicP, PublicB, PublicD, PublicC, PublicM, E, PublicProps, PublicDefaults, MakeDefaultsOptional, ComponentOptionsBase<P, B, D, C, M, Mixin, Extends, E, string, Defaults, {}, string, S, LC, Directives, Exposed, Provide>, I, S, Exposed, TypeRefs, TypeEl>;
-type ExposedKeys<T, Exposed extends string & keyof T> = '' extends Exposed ? T : Pick<T, Exposed>;
-type ComponentPublicInstance<P = {}, // props type extracted from props option
-B = {}, // raw bindings returned from setup()
-D = {}, // return from data()
-C extends ComputedOptions = {}, M extends MethodOptions = {}, E extends EmitsOptions = {}, PublicProps = {}, Defaults = {}, MakeDefaultsOptional extends boolean = false, Options = ComponentOptionsBase<any, any, any, any, any, any, any, any, any>, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, Exposed extends string = '', TypeRefs extends Data = {}, TypeEl extends Element = any> = {
-  $: ComponentInternalInstance;
-  $data: D;
-  $props: MakeDefaultsOptional extends true ? Partial<Defaults> & Omit<Prettify<P> & PublicProps, keyof Defaults> : Prettify<P> & PublicProps;
-  $attrs: Data;
-  $refs: Data & TypeRefs;
-  $slots: UnwrapSlotsType<S>;
-  $root: ComponentPublicInstance | null;
-  $parent: ComponentPublicInstance | null;
-  $host: Element | null;
-  $emit: EmitFn<E>;
-  $el: TypeEl;
-  $options: Options & MergedComponentOptionsOverride;
-  $forceUpdate: () => void;
-  $nextTick: typeof nextTick;
-  $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends ((...args: any) => infer R) ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
-} & ExposedKeys<IfAny<P, P, Readonly<Defaults> & Omit<P, keyof ShallowUnwrapRef<B> | keyof Defaults>> & ShallowUnwrapRef<B> & UnwrapNestedRefs<D> & ExtractComputedReturns<C> & M & ComponentCustomProperties & InjectToObject<I>, Exposed>;
-interface SuspenseProps {
-  onResolve?: () => void;
-  onPending?: () => void;
-  onFallback?: () => void;
-  timeout?: string | number;
-  /**
-   * Allow suspense to be captured by parent suspense
-   *
-   * @default false
-   */
-  suspensible?: boolean;
-}
-declare const SuspenseImpl: {
-  name: string;
-  __isSuspense: boolean;
-  process(n1: VNode | null, n2: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals): void;
-  hydrate: typeof hydrateSuspense;
-  normalize: typeof normalizeSuspenseChildren;
-};
-declare const Suspense: {
-  __isSuspense: true;
-  new (): {
-    $props: VNodeProps & SuspenseProps;
-    $slots: {
-      default(): VNode[];
-      fallback(): VNode[];
-    };
-  };
-};
-interface SuspenseBoundary {
-  vnode: VNode<RendererNode, RendererElement, SuspenseProps>;
-  parent: SuspenseBoundary | null;
-  parentComponent: ComponentInternalInstance | null;
-  namespace: ElementNamespace;
-  container: RendererElement;
-  hiddenContainer: RendererElement;
-  activeBranch: VNode | null;
-  pendingBranch: VNode | null;
-  deps: number;
-  pendingId: number;
-  timeout: number;
-  isInFallback: boolean;
-  isHydrating: boolean;
-  isUnmounted: boolean;
-  effects: Function[];
-  resolve(force?: boolean, sync?: boolean): void;
-  fallback(fallbackVNode: VNode): void;
-  move(container: RendererElement, anchor: RendererNode | null, type: MoveType): void;
-  next(): RendererNode | null;
-  registerDep(instance: ComponentInternalInstance, setupRenderEffect: SetupRenderEffectFn, optimized: boolean): void;
-  unmount(parentSuspense: SuspenseBoundary | null, doRemove?: boolean): void;
-}
-declare function hydrateSuspense(node: Node, vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals, hydrateNode: (node: Node, vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null;
-declare function normalizeSuspenseChildren(vnode: VNode): void;
-type Hook<T = () => void> = T | T[];
-interface BaseTransitionProps<HostElement = RendererElement> {
-  mode?: 'in-out' | 'out-in' | 'default';
-  appear?: boolean;
-  persisted?: boolean;
-  onBeforeEnter?: Hook<(el: HostElement) => void>;
-  onEnter?: Hook<(el: HostElement, done: () => void) => void>;
-  onAfterEnter?: Hook<(el: HostElement) => void>;
-  onEnterCancelled?: Hook<(el: HostElement) => void>;
-  onBeforeLeave?: Hook<(el: HostElement) => void>;
-  onLeave?: Hook<(el: HostElement, done: () => void) => void>;
-  onAfterLeave?: Hook<(el: HostElement) => void>;
-  onLeaveCancelled?: Hook<(el: HostElement) => void>;
-  onBeforeAppear?: Hook<(el: HostElement) => void>;
-  onAppear?: Hook<(el: HostElement, done: () => void) => void>;
-  onAfterAppear?: Hook<(el: HostElement) => void>;
-  onAppearCancelled?: Hook<(el: HostElement) => void>;
-}
-interface TransitionHooks<HostElement = RendererElement> {
-  mode: BaseTransitionProps['mode'];
-  persisted: boolean;
-  beforeEnter(el: HostElement): void;
-  enter(el: HostElement): void;
-  leave(el: HostElement, remove: () => void): void;
-  clone(vnode: VNode): TransitionHooks<HostElement>;
-  afterLeave?(): void;
-  delayLeave?(el: HostElement, earlyRemove: () => void, delayedLeave: () => void): void;
-  delayedLeave?(): void;
-}
-type ElementNamespace = 'svg' | 'mathml' | undefined;
-interface RendererOptions<HostNode = RendererNode, HostElement = RendererElement> {
-  patchProp(el: HostElement, key: string, prevValue: any, nextValue: any, namespace?: ElementNamespace, parentComponent?: ComponentInternalInstance | null): void;
-  insert(el: HostNode, parent: HostElement, anchor?: HostNode | null): void;
-  remove(el: HostNode): void;
-  createElement(type: string, namespace?: ElementNamespace, isCustomizedBuiltIn?: string, vnodeProps?: (VNodeProps & {
-    [key: string]: any;
-  }) | null): HostElement;
-  createText(text: string): HostNode;
-  createComment(text: string): HostNode;
-  setText(node: HostNode, text: string): void;
-  setElementText(node: HostElement, text: string): void;
-  parentNode(node: HostNode): HostElement | null;
-  nextSibling(node: HostNode): HostNode | null;
-  querySelector?(selector: string): HostElement | null;
-  setScopeId?(el: HostElement, id: string): void;
-  cloneNode?(node: HostNode): HostNode;
-  insertStaticContent?(content: string, parent: HostElement, anchor: HostNode | null, namespace: ElementNamespace, start?: HostNode | null, end?: HostNode | null): [HostNode, HostNode];
-}
-interface RendererNode {
-  [key: string | symbol]: any;
-}
-interface RendererElement extends RendererNode {}
-interface RendererInternals<HostNode = RendererNode, HostElement = RendererElement> {
-  p: PatchFn;
-  um: UnmountFn;
-  r: RemoveFn;
-  m: MoveFn;
-  mt: MountComponentFn;
-  mc: MountChildrenFn;
-  pc: PatchChildrenFn;
-  pbc: PatchBlockChildrenFn;
-  n: NextFn;
-  o: RendererOptions<HostNode, HostElement>;
-}
-type PatchFn = (n1: VNode | null, // null means this is a mount
-n2: VNode, container: RendererElement, anchor?: RendererNode | null, parentComponent?: ComponentInternalInstance | null, parentSuspense?: SuspenseBoundary | null, namespace?: ElementNamespace, slotScopeIds?: string[] | null, optimized?: boolean) => void;
-type MountChildrenFn = (children: VNodeArrayChildren, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, start?: number) => void;
-type PatchChildrenFn = (n1: VNode | null, n2: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean) => void;
-type PatchBlockChildrenFn = (oldChildren: VNode[], newChildren: VNode[], fallbackContainer: RendererElement, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null) => void;
-type MoveFn = (vnode: VNode, container: RendererElement, anchor: RendererNode | null, type: MoveType, parentSuspense?: SuspenseBoundary | null) => void;
-type NextFn = (vnode: VNode) => RendererNode | null;
-type UnmountFn = (vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, doRemove?: boolean, optimized?: boolean) => void;
-type RemoveFn = (vnode: VNode) => void;
-type MountComponentFn = (initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, optimized: boolean) => void;
-type SetupRenderEffectFn = (instance: ComponentInternalInstance, initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, optimized: boolean) => void;
-declare enum MoveType {
-  ENTER = 0,
-  LEAVE = 1,
-  REORDER = 2
-}
-/**
- * The createRenderer function accepts two generic arguments:
- * HostNode and HostElement, corresponding to Node and Element types in the
- * host environment. For example, for runtime-dom, HostNode would be the DOM
- * `Node` interface and HostElement would be the DOM `Element` interface.
- *
- * Custom renderers can pass in the platform specific types like this:
- *
- * ``` js
- * const { render, createApp } = createRenderer<Node, Element>({
- *   patchProp,
- *   ...nodeOps
- * })
- * ```
- */
-type MatchPattern = string | RegExp | (string | RegExp)[];
-interface KeepAliveProps {
-  include?: MatchPattern;
-  exclude?: MatchPattern;
-  max?: number | string;
-}
-type DebuggerHook = (e: DebuggerEvent) => void;
-type ErrorCapturedHook<TError = unknown> = (err: TError, instance: ComponentPublicInstance | null, info: string) => boolean | void;
-declare enum DeprecationTypes$1 {
-  GLOBAL_MOUNT = "GLOBAL_MOUNT",
-  GLOBAL_MOUNT_CONTAINER = "GLOBAL_MOUNT_CONTAINER",
-  GLOBAL_EXTEND = "GLOBAL_EXTEND",
-  GLOBAL_PROTOTYPE = "GLOBAL_PROTOTYPE",
-  GLOBAL_SET = "GLOBAL_SET",
-  GLOBAL_DELETE = "GLOBAL_DELETE",
-  GLOBAL_OBSERVABLE = "GLOBAL_OBSERVABLE",
-  GLOBAL_PRIVATE_UTIL = "GLOBAL_PRIVATE_UTIL",
-  CONFIG_SILENT = "CONFIG_SILENT",
-  CONFIG_DEVTOOLS = "CONFIG_DEVTOOLS",
-  CONFIG_KEY_CODES = "CONFIG_KEY_CODES",
-  CONFIG_PRODUCTION_TIP = "CONFIG_PRODUCTION_TIP",
-  CONFIG_IGNORED_ELEMENTS = "CONFIG_IGNORED_ELEMENTS",
-  CONFIG_WHITESPACE = "CONFIG_WHITESPACE",
-  CONFIG_OPTION_MERGE_STRATS = "CONFIG_OPTION_MERGE_STRATS",
-  INSTANCE_SET = "INSTANCE_SET",
-  INSTANCE_DELETE = "INSTANCE_DELETE",
-  INSTANCE_DESTROY = "INSTANCE_DESTROY",
-  INSTANCE_EVENT_EMITTER = "INSTANCE_EVENT_EMITTER",
-  INSTANCE_EVENT_HOOKS = "INSTANCE_EVENT_HOOKS",
-  INSTANCE_CHILDREN = "INSTANCE_CHILDREN",
-  INSTANCE_LISTENERS = "INSTANCE_LISTENERS",
-  INSTANCE_SCOPED_SLOTS = "INSTANCE_SCOPED_SLOTS",
-  INSTANCE_ATTRS_CLASS_STYLE = "INSTANCE_ATTRS_CLASS_STYLE",
-  OPTIONS_DATA_FN = "OPTIONS_DATA_FN",
-  OPTIONS_DATA_MERGE = "OPTIONS_DATA_MERGE",
-  OPTIONS_BEFORE_DESTROY = "OPTIONS_BEFORE_DESTROY",
-  OPTIONS_DESTROYED = "OPTIONS_DESTROYED",
-  WATCH_ARRAY = "WATCH_ARRAY",
-  PROPS_DEFAULT_THIS = "PROPS_DEFAULT_THIS",
-  V_ON_KEYCODE_MODIFIER = "V_ON_KEYCODE_MODIFIER",
-  CUSTOM_DIR = "CUSTOM_DIR",
-  ATTR_FALSE_VALUE = "ATTR_FALSE_VALUE",
-  ATTR_ENUMERATED_COERCION = "ATTR_ENUMERATED_COERCION",
-  TRANSITION_CLASSES = "TRANSITION_CLASSES",
-  TRANSITION_GROUP_ROOT = "TRANSITION_GROUP_ROOT",
-  COMPONENT_ASYNC = "COMPONENT_ASYNC",
-  COMPONENT_FUNCTIONAL = "COMPONENT_FUNCTIONAL",
-  COMPONENT_V_MODEL = "COMPONENT_V_MODEL",
-  RENDER_FUNCTION = "RENDER_FUNCTION",
-  FILTERS = "FILTERS",
-  PRIVATE_APIS = "PRIVATE_APIS"
-}
-type CompatConfig = Partial<Record<DeprecationTypes$1, boolean | 'suppress-warning'>> & {
-  MODE?: 2 | 3 | ((comp: Component | null) => 2 | 3);
-};
-/**
- * Interface for declaring custom options.
- *
- * @example
- * ```ts
- * declare module 'vue' {
- *   interface ComponentCustomOptions {
- *     beforeRouteUpdate?(
- *       to: Route,
- *       from: Route,
- *       next: () => void
- *     ): void
- *   }
- * }
- * ```
- */
-interface ComponentCustomOptions {}
-type RenderFunction = () => VNodeChild;
-interface ComponentOptionsBase<Props, RawBindings, D, C extends ComputedOptions, M extends MethodOptions, Mixin extends ComponentOptionsMixin, Extends extends ComponentOptionsMixin, E extends EmitsOptions, EE extends string = string, Defaults = {}, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions> extends LegacyOptions<Props, D, C, M, Mixin, Extends, I, II, Provide>, ComponentInternalOptions, ComponentCustomOptions {
-  setup?: (this: void, props: LooseRequired<Props & Prettify<UnwrapMixinsType<IntersectionMixin<Mixin> & IntersectionMixin<Extends>, 'P'>>>, ctx: SetupContext<E, S>) => Promise<RawBindings> | RawBindings | RenderFunction | void;
-  name?: string;
-  template?: string | object;
-  render?: Function;
-  components?: LC & Record<string, Component>;
-  directives?: Directives & Record<string, Directive>;
-  inheritAttrs?: boolean;
-  emits?: (E | EE[]) & ThisType<void>;
-  slots?: S;
-  expose?: Exposed[];
-  serverPrefetch?(): void | Promise<any>;
-  compilerOptions?: RuntimeCompilerOptions;
-  call?: (this: unknown, ...args: unknown[]) => never;
-  __isFragment?: never;
-  __isTeleport?: never;
-  __isSuspense?: never;
-  __defaults?: Defaults;
-}
-/**
- * Subset of compiler options that makes sense for the runtime.
- */
-interface RuntimeCompilerOptions {
-  isCustomElement?: (tag: string) => boolean;
-  whitespace?: 'preserve' | 'condense';
-  comments?: boolean;
-  delimiters?: [string, string];
-}
-type ComponentOptions<Props = {}, RawBindings = any, D = any, C extends ComputedOptions = any, M extends MethodOptions = any, Mixin extends ComponentOptionsMixin = any, Extends extends ComponentOptionsMixin = any, E extends EmitsOptions = any, EE extends string = string, Defaults = {}, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions> = ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, I, II, S, LC, Directives, Exposed, Provide> & ThisType<CreateComponentPublicInstanceWithMixins<{}, RawBindings, D, C, M, Mixin, Extends, E, Readonly<Props>, Defaults, false, I, S, LC, Directives>>;
-type ComponentOptionsMixin = ComponentOptionsBase<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>;
-type ComputedOptions = Record<string, ComputedGetter<any> | WritableComputedOptions<any>>;
-interface MethodOptions {
-  [key: string]: Function;
-}
-type ExtractComputedReturns<T extends any> = { [key in keyof T]: T[key] extends {
-  get: (...args: any[]) => infer TReturn;
-} ? TReturn : T[key] extends ((...args: any[]) => infer TReturn) ? TReturn : never };
-type ObjectWatchOptionItem = {
-  handler: WatchCallback | string;
-} & WatchOptions;
-type WatchOptionItem = string | WatchCallback | ObjectWatchOptionItem;
-type ComponentWatchOptionItem = WatchOptionItem | WatchOptionItem[];
-type ComponentWatchOptions = Record<string, ComponentWatchOptionItem>;
-type ComponentProvideOptions = ObjectProvideOptions | Function;
-type ObjectProvideOptions = Record<string | symbol, unknown>;
-type ComponentInjectOptions = string[] | ObjectInjectOptions;
-type ObjectInjectOptions = Record<string | symbol, string | symbol | {
-  from?: string | symbol;
-  default?: unknown;
-}>;
-type InjectToObject<T extends ComponentInjectOptions> = T extends string[] ? { [K in T[number]]?: unknown } : T extends ObjectInjectOptions ? { [K in keyof T]?: unknown } : never;
-interface LegacyOptions<Props, D, C extends ComputedOptions, M extends MethodOptions, Mixin extends ComponentOptionsMixin, Extends extends ComponentOptionsMixin, I extends ComponentInjectOptions, II extends string, Provide extends ComponentProvideOptions = ComponentProvideOptions> {
-  compatConfig?: CompatConfig;
-  [key: string]: any;
-  data?: (this: CreateComponentPublicInstanceWithMixins<Props, {}, {}, {}, MethodOptions, Mixin, Extends>, vm: CreateComponentPublicInstanceWithMixins<Props, {}, {}, {}, MethodOptions, Mixin, Extends>) => D;
-  computed?: C;
-  methods?: M;
-  watch?: ComponentWatchOptions;
-  provide?: Provide;
-  inject?: I | II[];
-  filters?: Record<string, Function>;
-  mixins?: Mixin[];
-  extends?: Extends;
-  beforeCreate?(): any;
-  created?(): any;
-  beforeMount?(): any;
-  mounted?(): any;
-  beforeUpdate?(): any;
-  updated?(): any;
-  activated?(): any;
-  deactivated?(): any;
-  /** @deprecated use `beforeUnmount` instead */
-  beforeDestroy?(): any;
-  beforeUnmount?(): any;
-  /** @deprecated use `unmounted` instead */
-  destroyed?(): any;
-  unmounted?(): any;
-  renderTracked?: DebuggerHook;
-  renderTriggered?: DebuggerHook;
-  errorCaptured?: ErrorCapturedHook;
-  /**
-   * runtime compile only
-   * @deprecated use `compilerOptions.delimiters` instead.
-   */
-  delimiters?: [string, string];
-  /**
-   * #3468
-   *
-   * type-only, used to assist Mixin's type inference,
-   * TypeScript will try to simplify the inferred `Mixin` type,
-   * with the `__differentiator`, TypeScript won't be able to combine different mixins,
-   * because the `__differentiator` will be different
-   */
-  __differentiator?: keyof D | keyof C | keyof M;
-}
-type MergedHook<T = () => void> = T | T[];
-type MergedComponentOptionsOverride = {
-  beforeCreate?: MergedHook;
-  created?: MergedHook;
-  beforeMount?: MergedHook;
-  mounted?: MergedHook;
-  beforeUpdate?: MergedHook;
-  updated?: MergedHook;
-  activated?: MergedHook;
-  deactivated?: MergedHook; /** @deprecated use `beforeUnmount` instead */
-  beforeDestroy?: MergedHook;
-  beforeUnmount?: MergedHook; /** @deprecated use `unmounted` instead */
-  destroyed?: MergedHook;
-  unmounted?: MergedHook;
-  renderTracked?: MergedHook<DebuggerHook>;
-  renderTriggered?: MergedHook<DebuggerHook>;
-  errorCaptured?: MergedHook<ErrorCapturedHook>;
-};
-type OptionTypesKeys = 'P' | 'B' | 'D' | 'C' | 'M' | 'Defaults';
-type OptionTypesType<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Defaults = {}> = {
-  P: P;
-  B: B;
-  D: D;
-  C: C;
-  M: M;
-  Defaults: Defaults;
-};
-/**
- * @deprecated
- */
-interface InjectionConstraint<T> {}
-type InjectionKey<T> = symbol & InjectionConstraint<T>;
-type PublicProps = VNodeProps & AllowedComponentProps & ComponentCustomProps;
-type ResolveProps<PropsOrPropOptions, E extends EmitsOptions> = Readonly<PropsOrPropOptions extends ComponentPropsOptions ? ExtractPropTypes<PropsOrPropOptions> : PropsOrPropOptions> & ({} extends E ? {} : EmitsToProps<E>);
-type DefineComponent<PropsOrPropOptions = {}, RawBindings = {}, D = {}, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, PP = PublicProps, Props = ResolveProps<PropsOrPropOptions, E>, Defaults = ExtractDefaultPropTypes<PropsOrPropOptions>, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions, MakeDefaultsOptional extends boolean = true, TypeRefs extends Record<string, unknown> = {}, TypeEl extends Element = any> = ComponentPublicInstanceConstructor<CreateComponentPublicInstanceWithMixins<Props, RawBindings, D, C, M, Mixin, Extends, E, PP, Defaults, MakeDefaultsOptional, {}, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, TypeRefs, TypeEl>> & ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, {}, string, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, Provide> & PP;
-interface App<HostElement = any> {
-  version: string;
-  config: AppConfig$1;
-  use<Options extends unknown[]>(plugin: Plugin$1<Options>, ...options: NoInfer<Options>): this;
-  use<Options>(plugin: Plugin$1<Options>, options: NoInfer<Options>): this;
-  mixin(mixin: ComponentOptions): this;
-  component(name: string): Component | undefined;
-  component<T extends Component | DefineComponent>(name: string, component: T): this;
-  directive<HostElement = any, Value = any, Modifiers extends string = string, Arg = any>(name: string): Directive<HostElement, Value, Modifiers, Arg> | undefined;
-  directive<HostElement = any, Value = any, Modifiers extends string = string, Arg = any>(name: string, directive: Directive<HostElement, Value, Modifiers, Arg>): this;
-  mount(rootContainer: HostElement | string,
-  /**
-   * @internal
-   */
-
-  isHydrate?: boolean,
-  /**
-   * @internal
-   */
-
-  namespace?: boolean | ElementNamespace,
-  /**
-   * @internal
-   */
-
-  vnode?: VNode): ComponentPublicInstance;
-  unmount(): void;
-  onUnmount(cb: () => void): void;
-  provide<T, K = InjectionKey<T> | string | number>(key: K, value: K extends InjectionKey<infer V> ? V : T): this;
-  /**
-   * Runs a function with the app as active instance. This allows using of `inject()` within the function to get access
-   * to variables provided via `app.provide()`.
-   *
-   * @param fn - function to run with the app as active instance
-   */
-  runWithContext<T>(fn: () => T): T;
-  _uid: number;
-  _component: ConcreteComponent;
-  _props: Data | null;
-  _container: HostElement | null;
-  _context: AppContext;
-  _instance: ComponentInternalInstance | null;
-  /**
-   * v2 compat only
-   */
-  filter?(name: string): Function | undefined;
-  filter?(name: string, filter: Function): this;
-}
-type OptionMergeFunction = (to: unknown, from: unknown) => any;
-interface AppConfig$1 {
-  readonly isNativeTag: (tag: string) => boolean;
-  performance: boolean;
-  optionMergeStrategies: Record<string, OptionMergeFunction>;
-  globalProperties: ComponentCustomProperties & Record<string, any>;
-  errorHandler?: (err: unknown, instance: ComponentPublicInstance | null, info: string) => void;
-  warnHandler?: (msg: string, instance: ComponentPublicInstance | null, trace: string) => void;
-  /**
-   * Options to pass to `@vue/compiler-dom`.
-   * Only supported in runtime compiler build.
-   */
-  compilerOptions: RuntimeCompilerOptions;
-  /**
-   * @deprecated use config.compilerOptions.isCustomElement
-   */
-  isCustomElement?: (tag: string) => boolean;
-  /**
-   * TODO document for 3.5
-   * Enable warnings for computed getters that recursively trigger itself.
-   */
-  warnRecursiveComputed?: boolean;
-  /**
-   * Whether to throw unhandled errors in production.
-   * Default is `false` to avoid crashing on any error (and only logs it)
-   * But in some cases, e.g. SSR, throwing might be more desirable.
-   */
-  throwUnhandledErrorInProduction?: boolean;
-  /**
-   * Prefix for all useId() calls within this app
-   */
-  idPrefix?: string;
-}
-interface AppContext {
-  app: App;
-  config: AppConfig$1;
-  mixins: ComponentOptions[];
-  components: Record<string, Component>;
-  directives: Record<string, Directive>;
-  provides: Record<string | symbol, any>;
-}
-type PluginInstallFunction<Options = any[]> = Options extends unknown[] ? (app: App, ...options: Options) => any : (app: App, options: Options) => any;
-type ObjectPlugin<Options = any[]> = {
-  install: PluginInstallFunction<Options>;
-};
-type FunctionPlugin<Options = any[]> = PluginInstallFunction<Options> & Partial<ObjectPlugin<Options>>;
-type Plugin$1<Options = any[], P extends unknown[] = (Options extends unknown[] ? Options : [Options])> = FunctionPlugin<P> | ObjectPlugin<P>;
-type TeleportVNode = VNode<RendererNode, RendererElement, TeleportProps>;
-interface TeleportProps {
-  to: string | RendererElement | null | undefined;
-  disabled?: boolean;
-  defer?: boolean;
-}
-declare const TeleportImpl: {
-  name: string;
-  __isTeleport: boolean;
-  process(n1: TeleportVNode | null, n2: TeleportVNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, internals: RendererInternals): void;
-  remove(vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, {
-    um: unmount,
-    o: {
-      remove: hostRemove
-    }
-  }: RendererInternals, doRemove: boolean): void;
-  move: typeof moveTeleport;
-  hydrate: typeof hydrateTeleport;
-};
-declare enum TeleportMoveTypes {
-  TARGET_CHANGE = 0,
-  TOGGLE = 1,
-  // enable / disable
-  REORDER = 2
-}
-declare function moveTeleport(vnode: VNode, container: RendererElement, parentAnchor: RendererNode | null, {
-  o: {
-    insert
-  },
-  m: move
-}: RendererInternals, moveType?: TeleportMoveTypes): void;
-declare function hydrateTeleport(node: Node, vnode: TeleportVNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean, {
-  o: {
-    nextSibling,
-    parentNode,
-    querySelector,
-    insert,
-    createText
-  }
-}: RendererInternals<Node, Element>, hydrateChildren: (node: Node | null, vnode: VNode, container: Element, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null;
-declare const Teleport: {
-  __isTeleport: true;
-  new (): {
-    $props: VNodeProps & TeleportProps;
-    $slots: {
-      default(): VNode[];
-    };
-  };
-};
-declare const Fragment: {
-  __isFragment: true;
-  new (): {
-    $props: VNodeProps;
-  };
-};
-declare const Text: unique symbol;
-declare const Comment: unique symbol;
-declare const Static: unique symbol;
-type VNodeTypes = string | VNode | Component | typeof Text | typeof Static | typeof Comment | typeof Fragment | typeof Teleport | typeof TeleportImpl | typeof Suspense | typeof SuspenseImpl;
-type VNodeRef = string | Ref | ((ref: Element | ComponentPublicInstance | null, refs: Record<string, any>) => void);
-type VNodeNormalizedRefAtom = {
-  /**
-   * component instance
-   */
-  i: ComponentInternalInstance;
-  /**
-   * Actual ref
-   */
-  r: VNodeRef;
-  /**
-   * setup ref key
-   */
-  k?: string;
-  /**
-   * refInFor marker
-   */
-  f?: boolean;
-};
-type VNodeNormalizedRef = VNodeNormalizedRefAtom | VNodeNormalizedRefAtom[];
-type VNodeMountHook = (vnode: VNode) => void;
-type VNodeUpdateHook = (vnode: VNode, oldVNode: VNode) => void;
-type VNodeProps = {
-  key?: PropertyKey;
-  ref?: VNodeRef;
-  ref_for?: boolean;
-  ref_key?: string;
-  onVnodeBeforeMount?: VNodeMountHook | VNodeMountHook[];
-  onVnodeMounted?: VNodeMountHook | VNodeMountHook[];
-  onVnodeBeforeUpdate?: VNodeUpdateHook | VNodeUpdateHook[];
-  onVnodeUpdated?: VNodeUpdateHook | VNodeUpdateHook[];
-  onVnodeBeforeUnmount?: VNodeMountHook | VNodeMountHook[];
-  onVnodeUnmounted?: VNodeMountHook | VNodeMountHook[];
-};
-type VNodeChildAtom = VNode | string | number | boolean | null | undefined | void;
-type VNodeArrayChildren = Array<VNodeArrayChildren | VNodeChildAtom>;
-type VNodeChild = VNodeChildAtom | VNodeArrayChildren;
-type VNodeNormalizedChildren = string | VNodeArrayChildren | RawSlots | null;
-interface VNode<HostNode = RendererNode, HostElement = RendererElement, ExtraProps = {
-  [key: string]: any;
-}> {
-  type: VNodeTypes;
-  props: (VNodeProps & ExtraProps) | null;
-  key: PropertyKey | null;
-  ref: VNodeNormalizedRef | null;
-  /**
-   * SFC only. This is assigned on vnode creation using currentScopeId
-   * which is set alongside currentRenderingInstance.
-   */
-  scopeId: string | null;
-  children: VNodeNormalizedChildren;
-  component: ComponentInternalInstance | null;
-  dirs: DirectiveBinding[] | null;
-  transition: TransitionHooks<HostElement> | null;
-  el: HostNode | null;
-  placeholder: HostNode | null;
-  anchor: HostNode | null;
-  target: HostElement | null;
-  targetStart: HostNode | null;
-  targetAnchor: HostNode | null;
-  suspense: SuspenseBoundary | null;
-  shapeFlag: number;
-  patchFlag: number;
-  appContext: AppContext | null;
-}
-type Data = Record<string, unknown>;
-/**
- * Public utility type for extracting the instance type of a component.
- * Works with all valid component definition types. This is intended to replace
- * the usage of `InstanceType<typeof Comp>` which only works for
- * constructor-based component definition types.
- *
- * @example
- * ```ts
- * const MyComp = { ... }
- * declare const instance: ComponentInstance<typeof MyComp>
- * ```
- */
-/**
- * For extending allowed non-declared props on components in TSX
- */
-interface ComponentCustomProps {}
-/**
- * For globally defined Directives
- * Here is an example of adding a directive `VTooltip` as global directive:
- *
- * @example
- * ```ts
- * import VTooltip from 'v-tooltip'
- *
- * declare module '@vue/runtime-core' {
- *   interface GlobalDirectives {
- *     VTooltip
- *   }
- * }
- * ```
- */
-interface GlobalDirectives {}
-/**
- * For globally defined Components
- * Here is an example of adding a component `RouterView` as global component:
- *
- * @example
- * ```ts
- * import { RouterView } from 'vue-router'
- *
- * declare module '@vue/runtime-core' {
- *   interface GlobalComponents {
- *     RouterView
- *   }
- * }
- * ```
- */
-interface GlobalComponents {
-  Teleport: DefineComponent<TeleportProps>;
-  Suspense: DefineComponent<SuspenseProps>;
-  KeepAlive: DefineComponent<KeepAliveProps>;
-  BaseTransition: DefineComponent<BaseTransitionProps>;
-}
-/**
- * Default allowed non-declared props on component in TSX
- */
-interface AllowedComponentProps {
-  class?: unknown;
-  style?: unknown;
-}
-interface ComponentInternalOptions {
-  /**
-   * Compat build only, for bailing out of certain compatibility behavior
-   */
-  __isBuiltIn?: boolean;
-  /**
-   * This one should be exposed so that devtools can make use of it
-   */
-  __file?: string;
-  /**
-   * name inferred from filename
-   */
-  __name?: string;
-}
-interface FunctionalComponent<P = {}, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any, EE extends EmitsOptions = ShortEmitsToObject<E>> extends ComponentInternalOptions {
-  (props: P & EmitsToProps<EE>, ctx: Omit<SetupContext<EE, IfAny<S, {}, SlotsType<S>>>, 'expose'>): any;
-  props?: ComponentPropsOptions<P>;
-  emits?: EE | (keyof EE)[];
-  slots?: IfAny<S, Slots, SlotsType<S>>;
-  inheritAttrs?: boolean;
-  displayName?: string;
-  compatConfig?: CompatConfig;
-}
-/**
- * Concrete component type matches its actual value: it's either an options
- * object, or a function. Use this where the code expects to work with actual
- * values, e.g. checking if its a function or not. This is mostly for internal
- * implementation code.
- */
-type ConcreteComponent<Props = {}, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any> = ComponentOptions<Props, RawBindings, D, C, M> | FunctionalComponent<Props, E, S>;
-/**
- * A type used in public APIs where a component type is expected.
- * The constructor type is an artificial type returned by defineComponent().
- */
-type Component<PropsOrInstance = any, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any> = ConcreteComponent<PropsOrInstance, RawBindings, D, C, M, E, S> | ComponentPublicInstanceConstructor<PropsOrInstance>;
-type SetupContext<E = EmitsOptions, S extends SlotsType = {}> = E extends any ? {
-  attrs: Data;
-  slots: UnwrapSlotsType<S>;
-  emit: EmitFn<E>;
-  expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed) => void;
-} : never;
-/**
- * We expose a subset of properties on the internal instance as they are
- * useful for advanced external libraries and tools.
- */
-interface ComponentInternalInstance {
-  uid: number;
-  type: ConcreteComponent;
-  parent: ComponentInternalInstance | null;
-  root: ComponentInternalInstance;
-  appContext: AppContext;
-  /**
-   * Vnode representing this component in its parent's vdom tree
-   */
-  vnode: VNode;
-  /**
-   * Root vnode of this component's own vdom tree
-   */
-  subTree: VNode;
-  /**
-   * Render effect instance
-   */
-  effect: ReactiveEffect;
-  /**
-   * Force update render effect
-   */
-  update: () => void;
-  /**
-   * Render effect job to be passed to scheduler (checks if dirty)
-   */
-  job: SchedulerJob;
-  proxy: ComponentPublicInstance | null;
-  exposed: Record<string, any> | null;
-  exposeProxy: Record<string, any> | null;
-  data: Data;
-  props: Data;
-  attrs: Data;
-  slots: InternalSlots;
-  refs: Data;
-  emit: EmitFn;
-  isMounted: boolean;
-  isUnmounted: boolean;
-  isDeactivated: boolean;
-}
-interface WatchEffectOptions extends DebuggerOptions {
-  flush?: 'pre' | 'post' | 'sync';
-}
-interface WatchOptions<Immediate = boolean> extends WatchEffectOptions {
-  immediate?: Immediate;
-  deep?: boolean | number;
-  once?: boolean;
-}
-declare module '@vue/reactivity' {
-  interface RefUnwrapBailTypes {
-    runtimeCoreBailTypes: VNode | {
-      $: ComponentInternalInstance;
-    };
-  }
-}
-// Note: this file is auto concatenated to the end of the bundled d.ts during
-// build.
-declare module '@vue/runtime-core' {
-  export interface GlobalComponents {
-    Teleport: DefineComponent<TeleportProps>;
-    Suspense: DefineComponent<SuspenseProps>;
-    KeepAlive: DefineComponent<KeepAliveProps>;
-    BaseTransition: DefineComponent<BaseTransitionProps>;
-  }
-} // Note: this file is auto concatenated to the end of the bundled d.ts during
-// build.
-type _defineProps = typeof defineProps;
-type _defineEmits = typeof defineEmits;
-type _defineExpose = typeof defineExpose;
-type _defineOptions = typeof defineOptions;
-type _defineSlots = typeof defineSlots;
-type _defineModel = typeof defineModel;
-type _withDefaults = typeof withDefaults;
-declare global {
-  const defineProps: _defineProps;
-  const defineEmits: _defineEmits;
-  const defineExpose: _defineExpose;
-  const defineOptions: _defineOptions;
-  const defineSlots: _defineSlots;
-  const defineModel: _defineModel;
-  const withDefaults: _withDefaults;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/@vue+runtime-dom@3.5.29/node_modules/@vue/runtime-dom/dist/runtime-dom.d.ts
-declare const TRANSITION = "transition";
-declare const ANIMATION = "animation";
-type AnimationTypes = typeof TRANSITION | typeof ANIMATION;
-interface TransitionProps extends BaseTransitionProps<Element> {
-  name?: string;
-  type?: AnimationTypes;
-  css?: boolean;
-  duration?: number | {
-    enter: number;
-    leave: number;
-  };
-  enterFromClass?: string;
-  enterActiveClass?: string;
-  enterToClass?: string;
-  appearFromClass?: string;
-  appearActiveClass?: string;
-  appearToClass?: string;
-  leaveFromClass?: string;
-  leaveActiveClass?: string;
-  leaveToClass?: string;
-}
-type TransitionGroupProps = Omit<TransitionProps, 'mode'> & {
-  tag?: string;
-  moveClass?: string;
-};
-declare const vShowOriginalDisplay: unique symbol;
-declare const vShowHidden: unique symbol;
-interface VShowElement extends HTMLElement {
-  [vShowOriginalDisplay]: string;
-  [vShowHidden]: boolean;
-}
-declare const vShow: ObjectDirective<VShowElement> & {
-  name: 'show';
-};
-declare const systemModifiers: readonly ["ctrl", "shift", "alt", "meta"];
-type SystemModifiers = (typeof systemModifiers)[number];
-type CompatModifiers = keyof typeof keyNames;
-type VOnModifiers = SystemModifiers | ModifierGuards | CompatModifiers;
-type ModifierGuards = 'shift' | 'ctrl' | 'alt' | 'meta' | 'left' | 'right' | 'stop' | 'prevent' | 'self' | 'middle' | 'exact';
-/**
- * @private
- */
-declare const keyNames: Record<'esc' | 'space' | 'up' | 'left' | 'right' | 'down' | 'delete', string>;
-/**
- * @private
- */
-type VOnDirective = Directive<any, any, VOnModifiers>;
-type AssignerFn = (value: any) => void;
-declare const assignKey: unique symbol;
-type ModelDirective<T, Modifiers extends string = string> = ObjectDirective<T & {
-  [assignKey]: AssignerFn;
-  _assigning?: boolean;
-}, any, Modifiers>;
-declare const vModelText: ModelDirective<HTMLInputElement | HTMLTextAreaElement, 'trim' | 'number' | 'lazy'>;
-declare const vModelCheckbox: ModelDirective<HTMLInputElement>;
-declare const vModelRadio: ModelDirective<HTMLInputElement>;
-declare const vModelSelect: ModelDirective<HTMLSelectElement, 'number'>;
-declare const vModelDynamic: ObjectDirective<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>;
-type VModelDirective = typeof vModelText | typeof vModelCheckbox | typeof vModelSelect | typeof vModelRadio | typeof vModelDynamic;
-/**
- * This is a stub implementation to prevent the need to use dom types.
- *
- * To enable proper types, add `"dom"` to `"lib"` in your `tsconfig.json`.
- */
-type DomType<T> = typeof globalThis extends {
-  window: unknown;
-} ? T : never;
-declare module '@vue/reactivity' {
-  interface RefUnwrapBailTypes {
-    runtimeDOMBailTypes: DomType<Node | Window>;
-  }
-}
-declare module '@vue/runtime-core' {
-  interface GlobalComponents {
-    Transition: DefineComponent<TransitionProps>;
-    TransitionGroup: DefineComponent<TransitionGroupProps>;
-  }
-  interface GlobalDirectives {
-    vShow: typeof vShow;
-    vOn: VOnDirective;
-    vBind: VModelDirective;
-    vIf: Directive<any, boolean>;
-    vOnce: Directive;
-    vSlot: Directive;
-  }
-}
-//#endregion
-//#region ../../packages/kit/dist/index.d.mts
-//#region src/types/components.d.ts
-/**
- * @kimesh/kit - Component Types
- */
-interface KimeshComponent {
-  /** Component name as used in templates */
-  name: string;
-  /** Path to the component file */
-  filePath: string;
-  /** Named export to use (default: 'default') */
-  export?: string;
-  /** Component prefix */
-  prefix?: string;
-  /** Register globally */
-  global?: boolean;
-  /** Priority for resolution (higher = preferred) */
-  priority?: number;
-  /** Source layer name */
-  layer?: string;
-}
-interface KimeshComponentsDir {
-  /** Path to the components directory */
-  path: string;
-  /** Component prefix */
-  prefix?: string;
-  /** Register globally */
-  global?: boolean;
-  /** Glob pattern for matching components */
-  pattern?: string | string[];
-  /** Patterns to ignore */
-  ignore?: string[];
-  /** File extensions to include */
-  extensions?: string[];
-  /** Enable deep scanning (subdirectories) */
-  deep?: boolean;
-  /** Source layer name */
-  layer?: string;
-} //#endregion
-//#region src/types/imports.d.ts
-/**
- * @kimesh/kit - Import Types
- */
-interface KimeshImport {
-  /** Import name */
-  name: string;
-  /** Alias for the import */
-  as?: string;
-  /** Module to import from */
-  from: string;
-  /** Is type-only import */
-  type?: boolean;
-  /** Priority for resolution */
-  priority?: number;
-  /** Source layer name */
-  layer?: string;
-}
-interface KimeshImportsDir {
-  /** Path to the directory */
-  path: string;
-  /** Only scan these patterns */
-  pattern?: string | string[];
-  /** Patterns to ignore */
-  ignore?: string[];
-  /** Import as type-only */
-  type?: boolean;
-  /** Source layer name */
-  layer?: string;
-}
-interface KimeshImportPreset {
-  /** Preset name (e.g., 'vue', 'vue-router') */
-  from: string;
-  /** Imports to include from the preset */
-  imports: string[];
-  /** Import as type-only */
-  type?: boolean;
-} //#endregion
-//#region src/types/router.d.ts
-/**
- * @kimesh/kit - Router Types
- */
-interface KimeshRoute {
-  /** Route name */
-  name?: string;
-  /** Route path */
-  path: string;
-  /** Component file path */
-  file?: string;
-  /** Child routes */
-  children?: KimeshRoute[];
-  /** Route meta */
-  meta?: Record<string, unknown>;
-  /** Source layer name */
-  layer?: string;
-}
-interface KimeshRouteMiddleware {
-  /** Middleware name */
-  name: string;
-  /** Middleware file path */
-  path: string;
-  /** Global middleware (applied to all routes) */
-  global?: boolean;
-  /** Source layer name */
-  layer?: string;
-} //#endregion
-//#region src/types/hooks.d.ts
-type HookResult = void | Promise<void>;
-/**
- * Normalized component directory for shadcn extension hook.
- * Defined inline to avoid circular dependency with @kimesh/shadcn.
- */
-interface ShadcnComponentDir {
-  /** Absolute or relative path to component directory */
-  path: string;
-  /** Component name prefix (e.g., 'Ui' for UiButton) */
-  prefix: string;
-}
-/**
- * Tailwind source entry for extension hook.
- * Defined inline to avoid circular dependency with @kimesh/tailwindcss.
- */
-interface TailwindSourceEntry {
-  /** Absolute path to source directory */
-  path: string;
-  /** Optional comment in generated CSS */
-  comment?: string;
-}
-interface KimeshHooks {
-  /** Called after config is loaded, before layers */
-  'config:loaded': (config: KimeshConfig) => HookResult;
-  /** Called after layers are resolved */
-  'layers:resolved': (layers: ResolvedLayer[]) => HookResult;
-  /** Called to extend layer configuration */
-  'layers:extend': (layers: ResolvedLayer[]) => HookResult;
-  /** Called when Kimesh is fully initialized and ready */
-  ready: (kimesh: Kimesh) => HookResult;
-  /** Called before modules are processed */
-  'modules:before': (kimesh: Kimesh) => HookResult;
-  /** Called after all modules are processed */
-  'modules:done': (kimesh: Kimesh) => HookResult;
-  /** Called before build starts */
-  'build:before': (kimesh: Kimesh) => HookResult;
-  /** Called after build completes */
-  'build:done': (kimesh: Kimesh) => HookResult;
-  /** Called on build error */
-  'build:error': (error: Error, kimesh: Kimesh) => HookResult;
-  /** Called to extend Vite config before it's resolved */
-  'vite:extend': (ctx: {
-    kimesh: Kimesh;
-    config: vite.UserConfig;
-  }) => HookResult;
-  /** Called after Vite config is resolved */
-  'vite:configResolved': (config: ResolvedConfig, kimesh: Kimesh) => HookResult;
-  /** Called when Vite dev server is created */
-  'vite:serverCreated': (server: ViteDevServer, kimesh: Kimesh) => HookResult;
-  /** Called to add import sources/presets */
-  'imports:sources': (sources: Array<{
-    from: string;
-    imports: string[];
-  }>, kimesh: Kimesh) => HookResult;
-  /** Called to extend imports */
-  'imports:extend': (imports: KimeshImport[], kimesh: Kimesh) => HookResult;
-  /** Called to add import directories */
-  'imports:dirs': (dirs: KimeshImportsDir[], kimesh: Kimesh) => HookResult;
-  /** Called to add component directories */
-  'components:dirs': (dirs: KimeshComponentsDir[], kimesh: Kimesh) => HookResult;
-  /** Called to extend components */
-  'components:extend': (components: KimeshComponent[], kimesh: Kimesh) => HookResult;
-  /** Called to add component resolvers */
-  'components:resolvers': (resolvers: ComponentResolver[], kimesh: Kimesh) => HookResult;
-  /** Called after routes are generated */
-  'routes:extend': (routes: KimeshRoute[], kimesh: Kimesh) => HookResult;
-  /** Called to add route middleware */
-  'routes:middleware': (middleware: KimeshRouteMiddleware[], kimesh: Kimesh) => HookResult;
-  /** Called when templates need generation */
-  'templates:extend': (templates: KimeshTemplate[], kimesh: Kimesh) => HookResult;
-  /** Called after templates are written */
-  'templates:done': (templates: KimeshTemplate[], kimesh: Kimesh) => HookResult;
-  /** Called to extend type templates */
-  'types:extend': (typeTemplates: KimeshTypeTemplate[], kimesh: Kimesh) => HookResult;
-  /** Called after types are generated */
-  'types:done': (files: string[], kimesh: Kimesh) => HookResult;
-  /** Called on file change in watch mode */
-  'watch:change': (file: string, event: 'add' | 'change' | 'unlink', kimesh: Kimesh) => HookResult;
-  /** Called before HMR update */
-  'hmr:before': (file: string, kimesh: Kimesh) => HookResult;
-  /** Called after HMR update */
-  'hmr:after': (file: string, kimesh: Kimesh) => HookResult;
-  /** Called when Kimesh is closing */
-  close: (kimesh: Kimesh) => HookResult;
-  /**
-   * Called by @kimesh/shadcn to allow extending modules to add component directories.
-   * Hook handlers can push entries to the componentDirs array.
-   *
-   * @example
-   * ```ts
-   * defineKimeshModule({
-   *   hooks: {
-   *     'shadcn:componentDirs:extend': (componentDirs) => {
-   *       componentDirs.push({
-   *         path: '/path/to/uikit/components',
-   *         prefix: 'Ui'
-   *       })
-   *     }
-   *   }
-   * })
-   * ```
-   */
-  'shadcn:componentDirs:extend': (componentDirs: ShadcnComponentDir[], kimesh: Kimesh) => HookResult;
-  /**
-   * Called by @kimesh/tailwindcss to allow extending modules to add source directories.
-   * Hook handlers can push entries to the sources array.
-   *
-   * @example
-   * ```ts
-   * defineKimeshModule({
-   *   hooks: {
-   *     'tailwindcss:sources:extend': (sources) => {
-   *       sources.push({
-   *         path: '/path/to/uikit/src',
-   *         comment: '@onesystem/uikit'
-   *       })
-   *     }
-   *   }
-   * })
-   * ```
-   */
-  'tailwindcss:sources:extend': (sources: TailwindSourceEntry[], kimesh: Kimesh) => HookResult;
-} //#endregion
-//#region src/types/runtime-plugin.d.ts
-/**
- * Metadata for runtime plugin ordering and identification
- */
-interface KimeshRuntimePluginMeta {
-  name?: string;
-  enforce?: 'pre' | 'default' | 'post';
-  order?: number;
-  dependsOn?: string[];
-  parallel?: boolean;
-}
-/**
- * Runtime hooks available in Kimesh app lifecycle
- */
-interface KimeshRuntimeHooks {
-  'app:created': (app: App) => void | Promise<void>;
-  'app:beforeMount': (app: App) => void | Promise<void>;
-  'app:mounted': (app: App) => void | Promise<void>;
-  'app:error': (err: unknown) => void | Promise<void>;
-  'page:start': () => void | Promise<void>;
-  'page:finish': () => void | Promise<void>;
-  'navigate:before': (context: {
-    to: unknown;
-    from: unknown;
-  }) => void | false | Promise<void | false>;
-  'navigate:after': (context: {
-    to: unknown;
-    from: unknown;
-    failure?: unknown;
-  }) => void | Promise<void>;
-  'navigate:error': (context: {
-    error: Error;
-    to: unknown;
-    from: unknown;
-  }) => void | Promise<void>;
-}
-interface RuntimeConfigPublic {
-  [key: string]: unknown;
-}
-/**
- * Minimal build-time app context. Full runtime version is in @kimesh/router-runtime.
- */
-interface KimeshAppContext {
-  vueApp: App;
-  router: unknown;
-  queryClient: unknown;
-  hooks: {
-    callHook: <T extends keyof KimeshRuntimeHooks>(name: T, ...args: Parameters<KimeshRuntimeHooks[T]>) => Promise<void>;
-    addHooks: (hooks: Partial<KimeshRuntimeHooks>) => void;
-  };
-  provide: <T>(name: string, value: T) => void;
-  $config: RuntimeConfigPublic;
-  isHydrating: boolean;
-  runWithContext: <T extends () => unknown>(fn: T) => ReturnType<T>;
-}
-interface KimeshRuntimePluginResult<Injections = Record<string, unknown>> {
-  provide?: Injections;
-}
-/** Plugin setup return type */
-type PluginSetupReturn<Injections> = void | KimeshRuntimePluginResult<Injections> | Promise<void> | Promise<KimeshRuntimePluginResult<Injections>>;
-/**
- * Runtime plugin function signature
- */
-interface KimeshRuntimePlugin<Injections = Record<string, unknown>> {
-  (app: KimeshAppContext): PluginSetupReturn<Injections>;
-  __kimesh_plugin?: true;
-  _name?: string;
-  meta?: KimeshRuntimePluginMeta;
-  hooks?: Partial<KimeshRuntimeHooks>;
-}
-/**
- * Object-style runtime plugin definition
- */
-/**
- * Normalized runtime plugin for registry storage
- */
-interface KimeshRuntimePluginEntry {
-  src?: string;
-  name?: string;
-  meta?: KimeshRuntimePluginMeta;
-  plugin?: KimeshRuntimePlugin;
-  append?: boolean;
-}
-//#endregion
-//#region src/types/kimesh.d.ts
-interface KimeshTemplate<TData = unknown> {
-  /** Output filename (relative to buildDir) */
-  filename: string;
-  /** Generate template contents */
-  getContents?: (data: TData & {
-    kimesh: Kimesh;
-  }) => string | Promise<string>;
-  /** Source file path (alternative to getContents) */
-  src?: string;
-  /** Write to disk (default: true) */
-  write?: boolean;
-  /** Custom data passed to getContents */
-  data?: TData;
-}
-interface KimeshTypeTemplate<TData = unknown> extends KimeshTemplate<TData> {
-  /** Always writes .d.ts files */
-  filename: `${string}.d.ts`;
-}
-interface KimeshAlias {
-  /** Alias name (e.g., '#my-alias', '@/components') */
-  find: string | RegExp;
-  /** Path to resolve to */
-  replacement: string;
-}
-interface KimeshVitePluginEntry {
-  /** The Vite plugin */
-  plugin: Plugin;
-  /** Plugin enforce order */
-  enforce?: 'pre' | 'post';
-  /** Numeric order (lower = earlier) */
-  order?: number;
-  /** Metadata for debugging */
-  meta?: {
-    name?: string;
-    module?: string;
-  };
-}
-interface KimeshRegistries {
-  /** Vite plugins to add */
-  vitePlugins: KimeshVitePluginEntry[];
-  /** Aliases */
-  aliases: KimeshAlias[];
-  /** Templates to generate */
-  templates: KimeshTemplate[];
-  /** Type templates to generate (.d.ts) */
-  typeTemplates: KimeshTypeTemplate[];
-  /** Auto-imports */
-  imports: KimeshImport[];
-  /** Auto-import directories */
-  importsDirs: KimeshImportsDir[];
-  /** Import presets */
-  importsPresets: KimeshImportPreset[];
-  /** Components */
-  components: KimeshComponent[];
-  /** Component directories */
-  componentsDirs: KimeshComponentsDir[];
-  /** Component resolvers */
-  componentResolvers: ComponentResolver[];
-  /** Routes */
-  routes: KimeshRoute[];
-  /** Route middleware */
-  routeMiddleware: KimeshRouteMiddleware[];
-  /** Runtime plugins (execute in Vue app at runtime) */
-  runtimePlugins: KimeshRuntimePluginEntry[];
-}
-interface KimeshOptions {
-  /** Whether in development mode */
-  dev: boolean;
-  /** Project root directory */
-  root: string;
-  /** Build output directory (.kimesh) */
-  buildDir: string;
-  /** The Kimesh configuration */
-  config: KimeshConfig;
-  /** Resolved layers */
-  layers: ResolvedLayer[];
-  /** Runtime config (exposed to client/server) */
-  runtimeConfig: {
-    public: Record<string, unknown>;
-    private: Record<string, unknown>;
-  };
-}
-interface Kimesh {
-  /** Kimesh options */
-  readonly options: KimeshOptions;
-  /** Hookable instance for lifecycle hooks */
-  readonly hooks: Hookable<KimeshHooks>;
-  /** Registries for plugins, templates, imports, components, etc. */
-  readonly _registries: KimeshRegistries;
-  /** Resolved layers (shorthand for options.layers) */
-  readonly layers: ResolvedLayer[];
-  /** Project root directory */
-  readonly root: string;
-  /** Build directory (.kimesh) */
-  readonly buildDir: string;
-  /** Register a hook */
-  hook: <T extends keyof KimeshHooks>(name: T, handler: KimeshHooks[T], options?: {
-    allowDeprecated?: boolean;
-  }) => () => void;
-  /** Call a hook */
-  callHook: <T extends keyof KimeshHooks>(name: T, ...args: Parameters<KimeshHooks[T]>) => Promise<void>;
-  /** Register a hook that runs only once */
-  hookOnce: <T extends keyof KimeshHooks>(name: T, handler: KimeshHooks[T]) => () => void;
-} //#endregion
-//#region src/types/module.d.ts
-interface KimeshModuleMeta {
-  /** Module name (npm package name) */
-  name?: string;
-  /** Module version */
-  version?: string;
-  /** Config key in kimesh.config.ts for module options */
-  configKey?: string;
-  /** Compatibility constraints */
-  compatibility?: {
-    /** Minimum Kimesh version required */kimesh?: string; /** Minimum Vite version required */
-    vite?: string;
-  };
-  /**
-   * Modules to auto-load before this module.
-   * Extended modules will be resolved and their hooks registered
-   * before this module's setup() is called.
-   *
-   * @example
-   * ```ts
-   * defineKimeshModule({
-   *   meta: {
-   *     name: '@onesystem/uikit',
-   *     extends: ['@kimesh/shadcn', '@kimesh/tailwindcss'],
-   *   },
-   *   // ...
-   * })
-   * ```
-   */
-  extends?: string[];
-}
-/**
- * Module defaults can be:
- * - A static object
- * - A function that receives Kimesh and returns defaults (sync or async)
- */
-type KimeshModuleDefaults<TOptions> = TOptions | ((kimesh: Kimesh) => TOptions | Promise<TOptions>);
-interface KimeshModuleDefinition<TOptions = Record<string, unknown>> {
-  /** Module metadata */
-  meta?: KimeshModuleMeta;
-  /** Default options (can be function for dynamic defaults) */
-  defaults?: KimeshModuleDefaults<Partial<TOptions>>;
-  /** Shorthand hook registration */
-  hooks?: Partial<KimeshHooks>;
-  /**
-   * Setup function called after layers are resolved
-   * @param options - Merged options (defaults + user config)
-   * @param kimesh - Kimesh context
-   */
-  setup?: (options: TOptions, kimesh: Kimesh) => void | Promise<void>;
-}
-/**
- * A resolved Kimesh module
- */
-interface KimeshModule<TOptions = Record<string, unknown>> {
-  /** Module definition */
-  _def: KimeshModuleDefinition<TOptions>;
-  /** Module meta (resolved) */
-  meta: Required<KimeshModuleMeta>;
-  /** Get default options */
-  getDefaults: (kimesh: Kimesh) => Promise<Partial<TOptions>>;
-  /** Setup function */
-  setup: (options: TOptions, kimesh: Kimesh) => void | Promise<void>;
-}
-/**
- * Module input in config - can be:
- * - A string package name (resolved from node_modules)
- * - A module object
- * - A tuple of [module, options]
- * - A tuple of [string, options]
- */
-type KimeshModuleInput<TOptions = any> = string | KimeshModule<TOptions> | [KimeshModule<TOptions>, Partial<TOptions>] | [string, Partial<TOptions>];
-//#endregion
-//#region src/types/config.d.ts
-/**
- * Runtime configuration that can be overridden by environment variables.
- *
- * Values are resolved at build-time via Vite's `define` mechanism.
- * Use `KIMESH_*` environment variables to override values.
- *
- * @example
- * ```ts
- * // In kimesh.config.ts
- * runtimeConfig: {
- *   apiBase: '/api', // KIMESH_API_BASE
- *   debug: false, // KIMESH_DEBUG=true
- *   features: {
- *     darkMode: true, // KIMESH_FEATURES_DARK_MODE
- *   }
- * }
- * ```
- */
-interface RuntimeConfig {
-  [key: string]: string | number | boolean | null | undefined | RuntimeConfig;
-}
-/**
- * Layer configuration in kimesh.config.ts
- */
-interface LayersConfig {
-  /** Directories to scan for layers (default: ['layers']) */
-  dirs?: string[];
-  /** Layers to enable - 'all' | 'none' | string[] */
-  enabled?: 'all' | 'none' | string[];
-  /** Layers to exclude */
-  excluded?: string[];
-}
-/**
- * Auto-import configuration in kimesh.config.ts
- */
-interface AutoImportOptions {
-  /** Enable auto-imports (default: true) */
-  enabled?: boolean;
-  /** Directories to scan for composables */
-  dirs?: string[];
-  /** External import presets (vue, vue-router, etc.) */
-  presets?: string[];
-  /** Custom import sources */
-  imports?: Array<{
-    from: string;
-    imports: string[];
-    type?: boolean;
-  }>;
-  /** Generate .d.ts files (default: true) */
-  dts?: boolean;
-}
-/**
- * Component auto-import configuration
- */
-interface ComponentsConfig {
-  /** Enable component auto-imports (default: true) */
-  enabled?: boolean;
-  /** Directories to scan */
-  dirs?: string[];
-  /** Component prefix */
-  prefix?: string;
-  /** Global component registration */
-  global?: boolean;
-}
-/**
- * Vite configuration options for Kimesh.
- */
-interface KimeshViteConfig extends Omit<UserConfig, 'root' | 'configFile'> {
-  /**
-   * Additional Vite plugins.
-   * These are merged AFTER Kimesh's internal plugins.
-   */
-  plugins?: PluginOption[];
-}
-/**
- * Default aliases provided by Kimesh.
- * Templates use placeholders: <srcDir>, <rootDir>
- * These are replaced at build time with actual paths.
- *
- * NOTE: `~` and `@` are NOT included here because they are handled by
- * the layer-alias-plugin for context-aware resolution. The plugin resolves
- * these aliases relative to the importing file's layer, not globally.
- *
- * @see packages/kit/src/vite/layer-alias-plugin.ts
- */
-/**
- * Debug mode configuration for detailed logging and diagnostics.
- */
-interface DebugConfig {
-  /**
-   * Log hook execution with timing information
-   * @default false
-   */
-  hooks?: boolean;
-  /**
-   * Log module loading and setup
-   * @default false
-   */
-  modules?: boolean;
-  /**
-   * Log layer resolution
-   * @default false
-   */
-  layers?: boolean;
-  /**
-   * Log configuration loading and merging
-   * @default false
-   */
-  config?: boolean;
-  /**
-   * Log Vite plugin operations
-   * @default false
-   */
-  vite?: boolean;
-  /**
-   * Log route generation
-   * @default false
-   */
-  routes?: boolean;
-  /**
-   * Log auto-import resolution
-   * @default false
-   */
-  imports?: boolean;
-}
-/**
- * Default file/folder ignore patterns
- */
-/**
- * Options for file ignore patterns (passed to node-ignore)
- */
-interface IgnoreOptions {
-  /**
-   * Whether matching is case-insensitive
-   * @default false
-   */
-  ignorecase?: boolean;
-}
-/**
- * Per-route configuration rules.
- * Keys are route patterns (supports wildcards).
- *
- * @example
- * ```ts
- * routeRules: {
- *   '/admin/**': {
- *     redirect: '/login',
- *   },
- *   '/api/**': {
- *     headers: { 'Cache-Control': 'no-store' },
- *   },
- *   '/static/**': {
- *     prerender: true,
- *   },
- * }
- * ```
- */
-interface RouteRule {
-  /**
-   * Redirect to another path
-   * Can be a string path or an object with statusCode
-   */
-  redirect?: string | {
-    to: string;
-    statusCode?: 301 | 302 | 307 | 308;
-  };
-  /**
-   * Pre-render this route at build time (for static generation)
-   * @default false
-   */
-  prerender?: boolean;
-  /**
-   * Cache configuration for this route
-   */
-  cache?: boolean | {
-    /**
-     * Cache max age in seconds
-     */
-    maxAge?: number;
-    /**
-     * Stale-while-revalidate in seconds
-     */
-    swr?: number;
-    /**
-     * Cache key modifiers
-     */
-    varies?: string[];
-  };
-  /**
-   * Custom headers to set for this route
-   */
-  headers?: Record<string, string>;
-  /**
-   * CORS configuration for this route
-   */
-  cors?: boolean | {
-    origin?: string | string[];
-    methods?: string[];
-    headers?: string[];
-    credentials?: boolean;
-  };
-  /**
-   * Custom meta data for the route
-   */
-  meta?: Record<string, unknown>;
-}
-/**
- * Directory configuration for Kimesh.
- * Customizes the default directory structure.
- */
-interface DirectoryConfig {
-  /**
-   * Directory for static assets
-   * @default 'assets'
-   */
-  assets?: string;
-  /**
-   * Directory for runtime plugins
-   * @default 'plugins'
-   */
-  plugins?: string;
-  /**
-   * Directory for public static files
-   * @default 'public'
-   */
-  public?: string;
-  /**
-   * Directory for shared code across the app
-   * @default 'shared'
-   */
-  shared?: string;
-}
-/**
- * Bundle analyzer configuration options.
- */
-interface AnalyzeConfig {
-  /**
-   * Enable the bundle analyzer
-   * @default false
-   */
-  enabled?: boolean;
-  /**
-   * Automatically open analyzer report in browser
-   * @default false
-   */
-  openAnalyzer?: boolean;
-  /**
-   * Custom filename for the report
-   * @default 'report.html'
-   */
-  reportFilename?: string;
-}
-/**
- * Build configuration for Kimesh.
- * Controls production build behavior.
- */
-interface BuildConfig {
-  /**
-   * Enable bundle analysis. Shows a visualization of bundle contents.
-   *
-   * @example
-   * ```ts
-   * build: {
-   *   analyze: true,
-   *   // or with options:
-   *   analyze: {
-   *     enabled: true,
-   *     openAnalyzer: false,
-   *     reportFilename: 'stats.html',
-   *   },
-   * }
-   * ```
-   */
-  analyze?: boolean | AnalyzeConfig;
-  /**
-   * Generate source maps for production builds.
-   * - `true`: Generate separate source map files
-   * - `'hidden'`: Generate source maps but don't reference them in bundles
-   * - `'inline'`: Inline source maps into bundles
-   * - `false`: No source maps
-   *
-   * @default false
-   */
-  sourcemap?: boolean | 'hidden' | 'inline';
-  /**
-   * Build target for esbuild/terser.
-   * Specifies the JS language version to target.
-   *
-   * @default 'esnext'
-   */
-  target?: string;
-  /**
-   * Minification strategy for production builds.
-   * - `true`: Use default minifier (oxc)
-   * - `'oxc'`: Fast minification with OXC (Vite 8 native)
-   * - `'terser'`: More aggressive minification with terser
-   * - `'esbuild'`: Legacy esbuild minification
-   * - `false`: No minification
-   *
-   * @default 'oxc'
-   */
-  minify?: boolean | 'oxc' | 'esbuild' | 'terser';
-}
-/**
- * HTTPS configuration options for dev server.
- */
-interface HttpsConfig {
-  /**
-   * Path to SSL key file
-   */
-  key?: string;
-  /**
-   * Path to SSL certificate file
-   */
-  cert?: string;
-}
-/**
- * Proxy target configuration.
- */
-interface ProxyOptions {
-  /**
-   * Target URL to proxy to
-   */
-  target: string;
-  /**
-   * Change the origin header to match target
-   * @default true
-   */
-  changeOrigin?: boolean;
-  /**
-   * Rewrite the URL path
-   */
-  rewrite?: (path: string) => string;
-  /**
-   * Whether to proxy WebSocket connections
-   * @default false
-   */
-  ws?: boolean;
-  /**
-   * SSL verification options
-   */
-  secure?: boolean;
-  /**
-   * Custom headers to send with the proxy request
-   */
-  headers?: Record<string, string>;
-}
-/**
- * CORS configuration options for dev server.
- */
-interface CorsOptions {
-  /**
-   * Allowed origins
-   * @default '*'
-   */
-  origin?: string | string[] | boolean;
-  /**
-   * Allowed HTTP methods
-   * @default ['GET', 'HEAD', 'PUT', 'PATCH', 'POST', 'DELETE']
-   */
-  methods?: string[];
-  /**
-   * Allowed headers
-   */
-  allowedHeaders?: string[];
-  /**
-   * Headers exposed to the client
-   */
-  exposedHeaders?: string[];
-  /**
-   * Allow credentials (cookies, authorization headers)
-   * @default false
-   */
-  credentials?: boolean;
-  /**
-   * Max age for preflight request caching (seconds)
-   * @default 86400
-   */
-  maxAge?: number;
-}
-/**
- * Enhanced development server configuration.
- */
-interface DevServerConfig {
-  /**
-   * Port to listen on
-   * @default 3000
-   */
-  port?: number;
-  /**
-   * Host to bind to.
-   * - `'localhost'`: Only accessible from this machine
-   * - `true` or `'0.0.0.0'`: Accessible from network
-   *
-   * @default 'localhost'
-   */
-  host?: string | boolean;
-  /**
-   * Automatically open browser when server starts
-   * @default false
-   */
-  open?: boolean;
-  /**
-   * Enable HTTPS for dev server.
-   * Set to `true` to use auto-generated certificates,
-   * or provide custom key/cert paths.
-   *
-   * @example
-   * ```ts
-   * dev: {
-   *   https: true, // Auto-generate certificates
-   *   // or with custom certs:
-   *   https: {
-   *     key: './certs/localhost.key',
-   *     cert: './certs/localhost.crt',
-   *   },
-   * }
-   * ```
-   */
-  https?: boolean | HttpsConfig;
-  /**
-   * Configure proxy rules for dev server.
-   * Useful for API proxying during development.
-   *
-   * @example
-   * ```ts
-   * dev: {
-   *   proxy: {
-   *     '/api': 'http://localhost:8080',
-   *     '/socket': {
-   *       target: 'ws://localhost:8081',
-   *       ws: true,
-   *     },
-   *   },
-   * }
-   * ```
-   */
-  proxy?: Record<string, string | ProxyOptions>;
-  /**
-   * Configure CORS for dev server.
-   * Set to `true` to enable default CORS settings.
-   *
-   * @default false
-   */
-  cors?: boolean | CorsOptions;
-  /**
-   * Exit if the specified port is already in use
-   * @default false
-   */
-  strictPort?: boolean;
-}
-/**
- * TypeScript configuration options for Kimesh.
- */
-interface TypeScriptConfig {
-  /**
-   * Enable strict TypeScript mode.
-   * When true, adds strict compiler options to generated tsconfig.
-   *
-   * @default true
-   */
-  strict?: boolean;
-  /**
-   * Enable type checking during development and/or build.
-   * - `true`: Enable type checking during both dev and build
-   * - `'build'`: Only type check during build
-   * - `false`: Disable type checking
-   *
-   * @default false
-   */
-  typeCheck?: boolean | 'build';
-  /**
-   * Additional tsconfig compiler options to merge with generated config.
-   * These options will extend the auto-generated `.kimesh/tsconfig.json`.
-   *
-   * @example
-   * ```ts
-   * typescript: {
-   *   tsConfig: {
-   *     compilerOptions: {
-   *       experimentalDecorators: true,
-   *       emitDecoratorMetadata: true,
-   *     },
-   *   },
-   * }
-   * ```
-   */
-  tsConfig?: {
-    compilerOptions?: Record<string, unknown>;
-    include?: string[];
-    exclude?: string[];
-    references?: Array<{
-      path: string;
-    }>;
-  };
-}
-/**
- * Chokidar watch options (simplified subset).
- * @see https://github.com/paulmillr/chokidar#api
- */
-interface ChokidarOptions {
-  /**
-   * Indicates whether the process should continue as long as files are being watched
-   * @default true
-   */
-  persistent?: boolean;
-  /**
-   * Patterns to ignore
-   */
-  ignored?: string | RegExp | string[] | ((path: string) => boolean);
-  /**
-   * Use polling instead of native events
-   * @default false
-   */
-  usePolling?: boolean;
-  /**
-   * Polling interval in milliseconds (if usePolling is true)
-   * @default 100
-   */
-  interval?: number;
-  /**
-   * Polling interval for binary files (if usePolling is true)
-   * @default 300
-   */
-  binaryInterval?: number;
-  /**
-   * Delay in milliseconds for stabilized 'add' events
-   * @default 2000
-   */
-  awaitWriteFinish?: boolean | {
-    stabilityThreshold?: number;
-    pollInterval?: number;
-  };
-  /**
-   * Use file descriptor watching instead of stat polling
-   * @default false
-   */
-  atomic?: boolean | number;
-  /**
-   * Watch depth limit (how many levels to traverse)
-   * @default undefined (no limit)
-   */
-  depth?: number;
-}
-/**
- * Watchers configuration for advanced file watching control.
- */
-interface WatchersConfig {
-  /**
-   * Chokidar options for file watching
-   */
-  chokidar?: ChokidarOptions;
-  /**
-   * Webpack watch options (for future use if needed)
-   */
-  webpack?: {
-    aggregateTimeout?: number;
-    poll?: boolean | number;
-    ignored?: string | RegExp | string[];
-  };
-}
-/**
- * Module options interface - augmented by modules via declaration merging.
- *
- * Modules augment this interface to add their config keys.
- * The keys become available in defineKmConfig once the module is installed.
- *
- * @example
- * ```ts
- * // In @kimesh/tailwindcss/types.ts:
- * declare module '@kimesh/kit' {
- *   interface KimeshModuleOptions {
- *     tailwindcss?: KimeshTailwindConfig
- *   }
- * }
- * ```
- */
-interface KimeshModuleOptions {
-  [key: string]: unknown;
-}
-/**
- * App-level configuration
- */
-interface AppConfig {
-  /**
-   * Global head configuration for the app
-   * Automatically enables @kimesh/head plugin when configured
-   */
-  head?: {
-    /** Page title */title?: string; /** Title template (e.g., '%s | My App') */
-    titleTemplate?: string | ((title: string) => string); /** Meta tags */
-    meta?: Array<Record<string, string | undefined>>; /** Link tags */
-    link?: Array<Record<string, string | undefined>>; /** Script tags */
-    script?: Array<Record<string, string | boolean | undefined>>; /** Style tags */
-    style?: Array<Record<string, string | undefined>>; /** HTML attributes */
-    htmlAttrs?: Record<string, string | undefined>; /** Body attributes */
-    bodyAttrs?: Record<string, string | undefined>;
-  };
-}
-/**
- * Kimesh configuration (kimesh.config.ts)
- *
- * Module options are typed via the KimeshModuleOptions interface.
- * Modules can augment this interface to add typesafe config keys.
- */
-interface KimeshConfig extends KimeshModuleOptions {
-  /** Application/layer name */
-  name?: string;
-  /** Base path for routes (for layers) */
-  basePath?: string;
-  /**
-   * Define additional aliases to access custom directories within your JavaScript and CSS.
-   *
-   * Aliases are automatically added to the generated TypeScript configurations
-   * for full type support and path auto-complete.
-   *
-   * NOTE: `~` and `@` are NOT included in default aliases. They are handled
-   * by layer-alias-plugin for context-aware resolution - resolving to the
-   * current layer's path, not the global host app path.
-   *
-   * @default { "~~": "/<rootDir>", "@@": "/<rootDir>", "#build": "/<rootDir>/.kimesh" }
-   *
-   * @example
-   * ```ts
-   * import { fileURLToPath } from 'node:url'
-   *
-   * export default defineKmConfig({
-   *   alias: {
-   *     'images': fileURLToPath(new URL('./assets/images', import.meta.url)),
-   *     'style': fileURLToPath(new URL('./assets/style', import.meta.url)),
-   *   },
-   * })
-   * ```
-   */
-  alias?: Record<string, string>;
-  /**
-   * Set to `true` to enable debug mode.
-   *
-   * Prints out hook names and timings, logs hook arguments,
-   * and provides detailed information about module loading and layer resolution.
-   *
-   * @default false
-   *
-   * @example
-   * ```ts
-   * export default defineKmConfig({
-   *   debug: true,
-   *   // or with specific options:
-   *   debug: {
-   *     hooks: true,
-   *     modules: true,
-   *     layers: true,
-   *   },
-   * })
-   * ```
-   */
-  debug?: boolean | DebugConfig;
-  /**
-   * Hooks are listeners to Kimesh events that are typically used in modules,
-   * but are also available in `kimesh.config.ts`.
-   *
-   * Internally, hooks follow a naming pattern using colons (e.g., build:done).
-   * For ease of configuration, you can structure them as an hierarchical object.
-   *
-   * @example
-   * ```ts
-   * export default defineKmConfig({
-   *   hooks: {
-   *     'ready': (kimesh) => {
-   *       console.log('Kimesh is ready!')
-   *     },
-   *     'build:done': (kimesh) => {
-   *       console.log('Build completed!')
-   *     },
-   *   },
-   * })
-   * ```
-   */
-  hooks?: Partial<KimeshHooks>;
-  /**
-   * Files matching glob patterns specified inside the `ignore` array
-   * will be ignored in building.
-   *
-   * More customizable than `ignorePrefix`: allows complex patterns.
-   *
-   * @default ["**\/*.stories.{js,cts,mts,ts,jsx,tsx}", "**\/*.{spec,test}.{js,cts,mts,ts,jsx,tsx}", "**\/*.d.{cts,mts,ts}", ".kimesh"]
-   *
-   * @example
-   * ```ts
-   * export default defineKmConfig({
-   *   ignore: [
-   *     '**\/__tests__/**',
-   *     '**\/*.mock.ts',
-   *     'legacy/**',
-   *   ],
-   * })
-   * ```
-   */
-  ignore?: string[];
-  /**
-   * Any file in routes, layouts, middleware directories will be ignored
-   * during the build process if its filename starts with the prefix specified.
-   *
-   * @default "-"
-   *
-   * @example
-   * ```ts
-   * export default defineKmConfig({
-   *   ignorePrefix: '_', // Ignore files starting with underscore
-   * })
-   * ```
-   */
-  ignorePrefix?: string;
-  /**
-   * Pass options directly to `node-ignore` (which is used by Kimesh to ignore files).
-   *
-   * @see https://github.com/kaelzhang/node-ignore
-   *
-   * @example
-   * ```ts
-   * export default defineKmConfig({
-   *   ignoreOptions: {
-   *     ignorecase: false, // Case-sensitive matching
-   *   },
-   * })
-   * ```
-   */
-  ignoreOptions?: IgnoreOptions;
-  /**
-   * Global route rules applied to matching routes.
-   *
-   * Keys are route patterns (supports wildcards with **).
-   * Useful for redirects, caching, and per-route configuration.
-   *
-   * @experimental This feature's API may change in the future.
-   *
-   * @example
-   * ```ts
-   * export default defineKmConfig({
-   *   routeRules: {
-   *     '/admin/**': {
-   *       redirect: '/login',
-   *     },
-   *     '/api/**': {
-   *       headers: { 'Cache-Control': 'no-store' },
-   *       cors: true,
-   *     },
-   *     '/blog/**': {
-   *       prerender: true,
-   *     },
-   *   },
-   * })
-   * ```
-   */
-  routeRules?: Record<string, RouteRule>;
-  /**
-   * Source directory for your application code.
-   * All relative paths are resolved from this directory.
-   *
-   * @default 'src'
-   *
-   * @example
-   * ```ts
-   * export default defineKmConfig({
-   *   srcDir: 'app', // Use 'app' instead of 'src'
-   * })
-   * ```
-   */
-  srcDir?: string;
-  /**
-   * Build output directory for Kimesh's generated files.
-   * Contains TypeScript configs, generated routes, and other build artifacts.
-   *
-   * @default '.kimesh'
-   *
-   * @example
-   * ```ts
-   * export default defineKmConfig({
-   *   buildDir: '.output', // Use '.output' instead of '.kimesh'
-   * })
-   * ```
-   */
-  buildDir?: string;
-  /**
-   * Directory configuration for customizing the project structure.
-   *
-   * @example
-   * ```ts
-   * export default defineKmConfig({
-   *   dir: {
-   *     assets: 'static/assets',
-   *     plugins: 'app/plugins',
-   *     public: 'public',
-   *     shared: 'lib/shared',
-   *   },
-   * })
-   * ```
-   */
-  dir?: DirectoryConfig;
-  /**
-   * Build configuration for production builds.
-   *
-   * @example
-   * ```ts
-   * export default defineKmConfig({
-   *   build: {
-   *     analyze: true,
-   *     sourcemap: 'hidden',
-   *     target: 'es2022',
-   *     minify: 'oxc',
-   *   },
-   * })
-   * ```
-   */
-  build?: BuildConfig;
-  /**
-   * Enhanced development server configuration.
-   * Supports HTTPS, proxy, CORS, and more.
-   *
-   * @example
-   * ```ts
-   * export default defineKmConfig({
-   *   dev: {
-   *     port: 3000,
-   *     host: 'localhost',
-   *     open: true,
-   *     https: true,
-   *     proxy: {
-   *       '/api': 'http://localhost:8080',
-   *     },
-   *     cors: true,
-   *     strictPort: false,
-   *   },
-   * })
-   * ```
-   */
-  dev?: DevServerConfig;
-  /**
-   * TypeScript configuration options.
-   *
-   * @example
-   * ```ts
-   * export default defineKmConfig({
-   *   typescript: {
-   *     strict: true,
-   *     typeCheck: 'build',
-   *     tsConfig: {
-   *       compilerOptions: {
-   *         experimentalDecorators: true,
-   *       },
-   *     },
-   *   },
-   * })
-   * ```
-   */
-  typescript?: TypeScriptConfig;
-  /**
-   * Additional file patterns to watch during development.
-   * Uses glob patterns relative to the project root.
-   *
-   * @example
-   * ```ts
-   * export default defineKmConfig({
-   *   watch: [
-   *     './custom-dir/**\/*',
-   *     './config/**\/*.json',
-   *   ],
-   * })
-   * ```
-   */
-  watch?: string[];
-  /**
-   * Advanced watcher configuration.
-   * Customize chokidar options for file watching.
-   *
-   * @example
-   * ```ts
-   * export default defineKmConfig({
-   *   watchers: {
-   *     chokidar: {
-   *       usePolling: true,
-   *       interval: 1000,
-   *       ignored: ['**\/.git/**'],
-   *     },
-   *   },
-   * })
-   * ```
-   */
-  watchers?: WatchersConfig;
-  /** Router configuration */
-  router?: {
-    /** Routes directory relative to srcDir (default: 'routes') */routesDir?: string; /** Import mode for route components */
-    importMode?: 'async' | 'sync';
-  };
-  /** Extend from other layers (paths or package names) */
-  extends?: Array<string | {
-    name: string;
-    path?: string;
-  }>;
-  /** Layers configuration */
-  layers?: LayersConfig;
-  /**
-   * Kimesh modules to load
-   */
-  modules?: KimeshModuleInput[];
-  /**
-   * App-level configuration
-   * Includes head management and other app-wide settings
-   */
-  app?: AppConfig;
-  /** Routes configuration (for layers) */
-  routes?: {
-    /** Base path for all routes */basePath?: string; /** Routes folder name */
-    folder?: string;
-  };
-  /** Auto-import configuration */
-  autoImport?: AutoImportOptions;
-  /** Component auto-import configuration */
-  components?: ComponentsConfig;
-  /** Composables configuration (for layers) */
-  composables?: {
-    /** Directories to scan */dirs?: string[];
-  };
-  /** CSS files to include */
-  css?: string[];
-  /**
-   * Vite configuration options.
-   */
-  vite?: KimeshViteConfig;
-  /**
-   * Runtime configuration with environment variable override support.
-   *
-   * In Phase 1, all config is client-side (build-time injection).
-   * Use KIMESH_* environment variables to override values.
-   *
-   * @example
-   * ```ts
-   * runtimeConfig: {
-   *   apiBase: '/api', // KIMESH_API_BASE
-   *   debug: false, // KIMESH_DEBUG=true
-   *   features: {
-   *     darkMode: true, // KIMESH_FEATURES_DARK_MODE
-   *   }
-   * }
-   * ```
-   */
-  runtimeConfig?: RuntimeConfig;
-}
-/**
- * Define Kimesh configuration with type inference.
- */
-//#endregion
-//#region ../../packages/kit/types.d.ts
-/**
- * Function type for defineKmConfig
- */
-type DefineKmConfig = (config: KimeshConfig) => KimeshConfig;
-declare global {
-  /**
-   * Define Kimesh configuration with type inference.
-   * This function is available globally in kimesh.config.ts files.
-   *
-   * @example
-   * ```ts
-   * export default defineKmConfig({
-   *   name: 'my-app',
-   *   dev: {
-   *     port: 3000,
-   *   },
-   * })
-   * ```
-   */
-  const defineKmConfig: DefineKmConfig;
-}
-//#endregion
 //#region src/types.d.ts
 /**
  * Configuration options for the Kimesh TailwindCSS module
@@ -3583,7 +52,7 @@ interface KimeshTailwindConfig {
  * })
  * ```
  */
-declare const _default: KimeshModule<KimeshTailwindConfig>;
+declare const _default: _kimesh_kit0.KimeshModule<KimeshTailwindConfig>;
 //#endregion
 //#region src/transform.d.ts
 /**