import * as magic_string0 from "magic-string";
import MagicString from "magic-string";
import { Logger } from "vite";

//#region src/core/types/comment.d.ts
interface Comment {
  type: string;
  start: string;
  end: string;
  regex: RegExp;
}
//#endregion
//#region src/core/context/generator/generator.d.ts
type UnhandledPolicy = 'throw' | 'keep' | 'remove';
interface GeneratorOptions {
  unhandled?: UnhandledPolicy;
}
/**
 * 生成器基类
 * 提供通用的 AST 遍历和节点处理逻辑
 */
declare abstract class Generator {
  readonly node: SimpleNode;
  readonly generates: (Generate | undefined)[];
  protected readonly options: GeneratorOptions;
  constructor(node: SimpleNode, generates?: (Generate | undefined)[], options?: GeneratorOptions);
  /**
   * 遍历 AST 节点
   */
  walk(node: SimpleNode): void;
  /**
   * 处理 CodeStatement 节点
   * 子类需要实现此方法
   */
  protected abstract handleCodeStatement(node: SimpleNode): void;
  /**
   * 处理自定义生成器的结果
   * 子类需要实现此方法
   */
  protected abstract handleGeneratorResult(node: SimpleNode, result: string): void;
  /**
   * 使用自定义生成器处理节点
   * 生成器返回值约定：
   * - string: 处理该节点
   * - null: 已手动处理
   * - undefined: 不处理，交给下一个生成器
   */
  private processWithCustomGenerators;
  /**
   * 处理未被任何生成器处理的节点
   */
  protected handleUnprocessedNode(node: SimpleNode): void;
  /**
   * 保留节点（用于 unhandled: 'keep' 策略）
   * 子类需要实现此方法
   */
  protected abstract handleKeepNode(node: SimpleNode): void;
}
//#endregion
//#region src/core/context/generator/code-generator.d.ts
interface CodeGeneratorOptions extends GeneratorOptions {}
/**
 * 纯代码生成器
 * 从 AST 节点生成代码字符串，不依赖 MagicString
 */
declare class CodeGenerator extends Generator {
  private generatedCode;
  /**
   * 添加代码片段到生成结果
   */
  append(code: string): void;
  /**
   * 处理 CodeStatement 节点
   */
  protected handleCodeStatement(node: SimpleNode): void;
  /**
   * 处理自定义生成器返回的结果
   */
  protected handleGeneratorResult(node: SimpleNode, result: string): void;
  /**
   * 保留节点（用于 unhandled: 'keep' 策略）
   */
  protected handleKeepNode(node: SimpleNode): void;
  /**
   * 生成最终代码
   */
  private generate;
  /**
   * 静态方法：从 AST 节点生成代码
   */
  static generate(node: SimpleNode, generates?: (Generate | undefined)[], options?: CodeGeneratorOptions): string;
}
//#endregion
//#region src/core/context/generator/ms-generator.d.ts
interface MsGeneratorOptions extends GeneratorOptions {}
/**
 * 基于 MagicString 的代码转换器
 * 用于在现有源码基础上进行修改和删除操作
 */
declare class MsGenerator extends Generator {
  readonly s: MagicString;
  private keepRanges;
  constructor(node: SimpleNode, generates: (Generate | undefined)[] | undefined, s: MagicString, options?: GeneratorOptions);
  keep(node: SimpleNode): void;
  replace(node: SimpleNode, code: string): void;
  /**
   * 处理 CodeStatement 节点
   */
  protected handleCodeStatement(node: SimpleNode): void;
  /**
   * 处理自定义生成器返回的结果
   */
  protected handleGeneratorResult(node: SimpleNode, result: string): void;
  /**
   * 保留节点（用于 unhandled: 'keep' 策略）
   */
  protected handleKeepNode(node: SimpleNode): void;
  private addKeepRange;
  private mergeKeepRanges;
  private applyExclusion;
  private removeUnkeptRanges;
  private hasValidRange;
  private validateNodeRange;
  private generate;
  /**
   * 静态方法：基于 MagicString 转换代码
   *
   * @param node - AST 节点
   * @param generates - 生成器函数数组
   * @param s - MagicString 实例
   * @param options - 选项
   */
  static generate(node: SimpleNode, generates: (Generate | undefined)[] | undefined, s: MagicString, options?: GeneratorOptions): void;
}
//#endregion
//#region src/core/context/lexer.d.ts
declare class Lexer {
  code: string;
  lexers: Lex[];
  current: number;
  tokens: SimpleToken[];
  constructor(code: string, lexers?: Lex[]);
  private lex;
  static lex(code: string, lexers?: Lex[]): SimpleToken[];
}
//#endregion
//#region src/core/context/parser.d.ts
declare class Parser {
  tokens: SimpleToken[];
  parsers: Parse[];
  ast: ProgramNode;
  current: number;
  constructor(tokens: SimpleToken[], parsers?: Parse[]);
  walk(): CodeStatement | {
    comment: string;
    type: string;
    start: number;
    end: number;
  };
  private parse;
  static parse(tokens: SimpleToken[], parsers?: Parse[]): ProgramNode;
}
//#endregion
//#region src/core/context/index.d.ts
declare function resolveOptions(options?: UserOptions): Required<UserOptions>;
declare function sortUserDirectives(directives: ObjectDirective[]): [ObjectDirective[], ObjectDirective[], ObjectDirective[]];
declare class Context {
  options: Required<UserOptions>;
  directives: ObjectDirective[];
  lexers: Lex[];
  parsers: Parse[];
  transforms: Transform[];
  generates: (Generate | undefined)[];
  filter: (id: string) => boolean;
  env: Record<string, any>;
  logger: Logger;
  constructor(options?: UserOptions);
  loadEnv(mode?: string): Record<string, string>;
  private _transform;
  transform(code: string, id: string): string | undefined;
  transformWithMap(code: string, id: string): {
    map: magic_string0.SourceMap;
    code: string;
  } | undefined;
}
//#endregion
//#region src/core/context/transformer.d.ts
declare class Transformer {
  program: ProgramNode;
  transforms: Transform[];
  constructor(program: ProgramNode, transforms?: Transform[]);
  walk(node: SimpleNode): SimpleNode | void;
  private transform;
  static transform(program: ProgramNode, transforms?: Transform[]): void | SimpleNode;
}
//#endregion
//#region src/core/types/directive.d.ts
interface SimpleToken {
  comment?: string;
  type: string;
  value: string;
  start?: number;
  end?: number;
  [x: string]: any;
}
interface SimpleNode {
  comment?: string;
  type: string;
  start?: number;
  end?: number;
  [x: string]: any;
}
type Lex<T = SimpleToken> = (this: Lexer, currentLine: string) => (T | void);
type Parse<T = SimpleToken, N = SimpleNode> = (this: Parser, currentToken: T) => (N | void);
type Transform<N = SimpleNode, ResultN = SimpleNode> = (this: Transformer, currentNode: N) => (ResultN | void);
type Generate = (this: Generator, ast: SimpleNode, comment?: Comment) => (string | void);
/**
 * Represents an object-based directive configuration for preprocessing.
 *
 * @template T - The type of token produced by the lexer, defaults to SimpleToken
 * @template N - The type of AST node produced by the parser, defaults to SimpleNode
 *
 * @property {('pre' | 'post')} [enforce] - Optional enforcement phase for when the directive should be applied
 * @property {Lex<T>} lex - Lexical analyzer function that tokenizes the input
 * @property {Parse<T, N>} parse - Parser function that converts tokens into AST nodes
 * @property {Transform<N>} transform - Transformation function that modifies AST nodes
 * @property {Generate} generate - Code generation function that produces the final output
 */
interface ObjectDirective<T = SimpleToken, N = SimpleNode> {
  enforce?: 'pre' | 'post';
  lex: Lex<T>;
  parse: Parse<T, N>;
  transform: Transform<N>;
  generate?: Generate;
}
interface FunctionDirective<T = SimpleToken, N = SimpleNode> {
  (context: Context): ObjectDirective<T, N>;
}
type Directive<T = SimpleToken, N = SimpleNode> = ObjectDirective<T, N> | FunctionDirective<T, N>;
//#endregion
//#region src/core/types/node.d.ts
interface ProgramNode extends SimpleNode {
  type: 'Program';
  body: SimpleNode[];
}
interface CodeStatement extends SimpleNode {
  type: 'CodeStatement';
  value: string;
}
interface IfStatement extends SimpleNode {
  type: 'IfStatement';
  test: string;
  consequent: SimpleNode[];
  alternate: SimpleNode[];
  kind: IfToken['type'];
}
interface DefineStatement extends SimpleNode {
  type: 'DefineStatement';
  kind: 'define' | 'undef';
  value: string;
}
interface MessageStatement extends SimpleNode {
  type: 'MessageStatement';
  kind: 'error' | 'warning' | 'info';
  value: string;
}
interface IncludeStatement extends SimpleNode {
  type: 'IncludeStatement';
  value: string;
  sourceFile?: string;
}
//#endregion
//#region src/core/types/token.d.ts
interface CodeToken extends SimpleToken {
  type: 'code';
  value: string;
}
interface IfToken extends SimpleToken {
  type: 'if' | 'else' | 'elif' | 'endif';
  value: string;
}
interface DefineToken extends SimpleToken {
  type: 'define' | 'undef';
  value: string;
}
interface MessageToken extends SimpleToken {
  type: 'error' | 'warning' | 'info';
  value: string;
}
interface IncludeToken extends SimpleToken {
  type: 'include';
  value: string;
}
//#endregion
//#region src/types.d.ts
type FilterPattern = ReadonlyArray<string | RegExp> | string | RegExp | null;
interface Options {
  cwd: string;
  directives: Directive[];
  include: FilterPattern;
  exclude: FilterPattern;
}
interface UserOptions extends Partial<Options> {}
//#endregion
export { CodeGenerator as A, Context as C, Lexer as D, Parser as E, Generator as M, GeneratorOptions as N, MsGenerator as O, Comment as P, Transform as S, sortUserDirectives as T, Lex as _, IfToken as a, SimpleNode as b, CodeStatement as c, IncludeStatement as d, MessageStatement as f, Generate as g, FunctionDirective as h, DefineToken as i, CodeGeneratorOptions as j, MsGeneratorOptions as k, DefineStatement as l, Directive as m, UserOptions as n, IncludeToken as o, ProgramNode as p, CodeToken as r, MessageToken as s, Options as t, IfStatement as u, ObjectDirective as v, resolveOptions as w, SimpleToken as x, Parse as y };