@tslite/core 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1215 @@
+type Node = NodeMap[keyof NodeMap];
+interface ExpressionMap {
+    ArrayExpression: ArrayExpression;
+    ArrowFunctionExpression: ArrowFunctionExpression;
+    AssignmentExpression: AssignmentExpression;
+    AwaitExpression: AwaitExpression;
+    BinaryExpression: BinaryExpression;
+    CallExpression: CallExpression;
+    ChainExpression: ChainExpression;
+    ConditionalExpression: ConditionalExpression;
+    FunctionExpression: FunctionExpression;
+    Identifier: Identifier;
+    JsonExpression: JsonExpression;
+    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;
+}
+interface NodeMap {
+    AssignmentProperty: AssignmentProperty;
+    CatchClause: CatchClause;
+    Expression: Expression;
+    Function: Function;
+    Identifier: Identifier;
+    Literal: Literal;
+    MethodDefinition: MethodDefinition;
+    Pattern: Pattern;
+    Program: Program;
+    Property: Property;
+    PropertyDefinition: PropertyDefinition;
+    SpreadElement: SpreadElement;
+    Statement: Statement;
+    SwitchCase: SwitchCase;
+    TemplateElement: TemplateElement;
+    VariableDeclarator: VariableDeclarator;
+    ImportDeclaration: ImportDeclaration;
+    ImportSpecifier: ImportSpecifier;
+    ImportDefaultSpecifier: ImportDefaultSpecifier;
+    ImportNamespaceSpecifier: ImportNamespaceSpecifier;
+}
+type Expression = ExpressionMap[keyof ExpressionMap];
+type Statement = ExpressionStatement | BlockStatement | EmptyStatement | DebuggerStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
+type CallExpression = SimpleCallExpression | NewExpression;
+type ChainElement = SimpleCallExpression | MemberExpression;
+type Declaration = FunctionDeclaration | VariableDeclaration;
+type Function = ArrowFunctionExpression | FunctionDeclaration | FunctionExpression;
+/**
+ * TSLite — a forma serializada da linguagem TSLite.
+ *
+ * JSON puro (dados estáticos) entremeado de ilhas executáveis marcadas com
+ * `#ast`, cujo valor é o tipo do nó ESTree. É portável, serializável e
+ * diffável: `encode()` produz, `decode()` consome, `printJson()` emite.
+ */
+type TSLite = string | number | boolean | null | TSLite[] | TSLiteMarker | {
+    [key: string]: TSLite;
+};
+/** Ilha executável dentro do TSLite (o valor de `#ast` é o tipo do nó). */
+interface TSLiteMarker {
+    "#ast": string;
+    [prop: string]: unknown;
+}
+/**
+ * SimpleNode — a forma de árvore simplificada produzida por `encode()`: um nó
+ * ESTree com os campos falsy omitidos e cada `ObjectExpression` colapsado em
+ * `JsonExpression` (cujo `body` é {@link TSLite}). Os tipos `Simple*` descrevem
+ * cada variante; este é o agregador.
+ */
+type SimpleNode = {
+    type: string;
+    [key: string]: any;
+};
+type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
+type Pattern = ArrayPattern | AssignmentPattern | Identifier | JsonExpression | MemberExpression | ObjectPattern | RestElement;
+type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
+type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
+type LogicalOperator = "||" | "&&" | "??";
+type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+type UpdateOperator = "++" | "--";
+interface ArrayExpression extends BaseExpression {
+    type: "ArrayExpression";
+    elements: Array<Expression | SpreadElement | null>;
+}
+interface ArrayPattern extends BasePattern {
+    type: "ArrayPattern";
+    elements: Array<Pattern | null>;
+}
+interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
+    type: "ArrowFunctionExpression";
+    expression: boolean;
+    body: BlockStatement | Expression;
+}
+interface AssignmentExpression extends BaseExpression {
+    type: "AssignmentExpression";
+    operator: AssignmentOperator;
+    left: Pattern | MemberExpression;
+    right: Expression;
+}
+interface AssignmentPattern extends BasePattern {
+    type: "AssignmentPattern";
+    left: Pattern;
+    right: Expression;
+}
+interface AssignmentProperty extends Property {
+    value: Pattern;
+    kind: "init";
+    method: boolean;
+}
+interface AwaitExpression extends BaseExpression {
+    type: "AwaitExpression";
+    argument: Expression;
+}
+interface BaseCallExpression extends BaseExpression {
+    callee: Expression;
+    arguments: Array<Expression | SpreadElement>;
+}
+interface BaseDeclaration extends BaseStatement {
+}
+interface BaseExpression extends BaseNode {
+}
+interface BaseForXStatement extends BaseStatement {
+    left: VariableDeclaration | Pattern;
+    right: Expression;
+    body: Statement;
+}
+interface BaseFunction extends BaseNode {
+    params: Pattern[];
+    generator?: boolean | undefined;
+    async?: boolean | undefined;
+    body: BlockStatement | Expression;
+}
+interface BaseNode extends BaseNodeWithoutComments {
+    leadingComments?: Comment[] | undefined;
+    trailingComments?: Comment[] | undefined;
+}
+interface BaseNodeWithoutComments {
+    type: string;
+    loc?: SourceLocation | null | undefined;
+    range?: [number, number] | undefined;
+}
+interface BasePattern extends BaseNode {
+}
+interface BaseStatement extends BaseNode {
+}
+interface BigIntLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value?: bigint | null | undefined;
+    bigint: string;
+    raw?: string | undefined;
+}
+interface BinaryExpression extends BaseExpression {
+    type: "BinaryExpression";
+    operator: BinaryOperator;
+    left: Expression;
+    right: Expression;
+}
+interface BlockStatement extends BaseStatement {
+    type: "BlockStatement";
+    body: Statement[];
+    innerComments?: Comment[] | undefined;
+}
+interface BreakStatement extends BaseStatement {
+    type: "BreakStatement";
+    label?: Identifier | null | undefined;
+}
+interface CatchClause extends BaseNode {
+    type: "CatchClause";
+    param: Pattern | null;
+    body: BlockStatement;
+}
+interface ChainExpression extends BaseExpression {
+    type: "ChainExpression";
+    expression: ChainElement;
+}
+interface Comment extends BaseNodeWithoutComments {
+    type: "Line" | "Block";
+    value: string;
+}
+interface ConditionalExpression extends BaseExpression {
+    type: "ConditionalExpression";
+    test: Expression;
+    alternate: Expression;
+    consequent: Expression;
+}
+interface ContinueStatement extends BaseStatement {
+    type: "ContinueStatement";
+    label?: Identifier | null | undefined;
+}
+interface DebuggerStatement extends BaseStatement {
+    type: "DebuggerStatement";
+}
+interface Directive extends BaseNode {
+    type: "ExpressionStatement";
+    expression: Literal;
+    directive: string;
+}
+interface DoWhileStatement extends BaseStatement {
+    type: "DoWhileStatement";
+    body: Statement;
+    test: Expression;
+}
+interface EmptyStatement extends BaseStatement {
+    type: "EmptyStatement";
+}
+interface ExpressionStatement extends BaseStatement {
+    type: "ExpressionStatement";
+    expression: Expression;
+}
+interface ForInStatement extends BaseForXStatement {
+    type: "ForInStatement";
+}
+interface ForOfStatement extends BaseForXStatement {
+    type: "ForOfStatement";
+    await: boolean;
+}
+interface ForStatement extends BaseStatement {
+    type: "ForStatement";
+    init?: VariableDeclaration | Expression | null | undefined;
+    test?: Expression | null | undefined;
+    update?: Expression | null | undefined;
+    body: Statement;
+}
+interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
+    id: Identifier;
+}
+interface FunctionExpression extends BaseFunction, BaseExpression {
+    id?: Identifier | null | undefined;
+    type: "FunctionExpression";
+    body: BlockStatement;
+}
+interface Identifier extends BaseNode, BaseExpression, BasePattern {
+    type: "Identifier";
+    name: string;
+}
+interface IfStatement extends BaseStatement {
+    type: "IfStatement";
+    test: Expression;
+    consequent: Statement;
+    alternate?: Statement | null | undefined;
+}
+interface JsonExpression extends BaseNode, BaseExpression, BasePattern {
+    type: "JsonExpression";
+    body: TSLite;
+}
+interface LabeledStatement extends BaseStatement {
+    type: "LabeledStatement";
+    label: Identifier;
+    body: Statement;
+}
+interface LogicalExpression extends BaseExpression {
+    type: "LogicalExpression";
+    operator: LogicalOperator;
+    left: Expression;
+    right: Expression;
+}
+interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
+    type: "FunctionDeclaration";
+    id: Identifier | null;
+    body: BlockStatement;
+}
+interface MemberExpression extends BaseExpression, BasePattern {
+    type: "MemberExpression";
+    object: Expression;
+    property: Expression;
+    computed?: boolean;
+    optional?: boolean;
+}
+interface MetaProperty extends BaseExpression {
+    type: "MetaProperty";
+    meta: Identifier;
+    property: Identifier;
+}
+type ModuleDeclaration = ImportDeclaration;
+interface BaseModuleDeclaration extends BaseNode {
+}
+type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier;
+interface BaseModuleSpecifier extends BaseNode {
+    local: Identifier;
+}
+interface MethodDefinition extends BaseNode {
+    type: "MethodDefinition";
+    key: Expression;
+    value: FunctionExpression;
+    kind: "constructor" | "method" | "get" | "set";
+    computed?: boolean;
+    static: boolean;
+}
+interface NewExpression extends BaseCallExpression {
+    type: "NewExpression";
+}
+interface ObjectExpression extends BaseExpression {
+    type: "ObjectExpression";
+    properties: Array<Property | SpreadElement>;
+}
+interface ObjectPattern extends BasePattern {
+    type: "ObjectPattern";
+    properties: Array<AssignmentProperty | RestElement>;
+}
+interface Position {
+    line: number;
+    column: number;
+}
+interface Program extends BaseNode {
+    type: "Program";
+    sourceType: "script" | "module";
+    body: Array<Directive | Statement | ModuleDeclaration>;
+    comments?: Comment[] | undefined;
+}
+interface Property extends BaseNode {
+    type: "Property";
+    key: Expression;
+    value: Expression | Pattern | AssignmentProperty;
+    kind: "init" | "get" | "set";
+    method?: boolean;
+    shorthand?: boolean;
+    computed?: boolean;
+}
+interface PropertyDefinition extends BaseNode {
+    type: "PropertyDefinition";
+    key: Expression;
+    value?: Expression | null | undefined;
+    computed?: boolean;
+    static: boolean;
+}
+interface RegExpLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value?: RegExp | null | undefined;
+    regex: {
+        pattern: string;
+        flags: string;
+    };
+    raw?: string | undefined;
+}
+interface RestElement extends BasePattern {
+    type: "RestElement";
+    argument: Pattern;
+}
+interface ReturnStatement extends BaseStatement {
+    type: "ReturnStatement";
+    argument?: Expression | null | undefined;
+}
+interface SequenceExpression extends BaseExpression {
+    type: "SequenceExpression";
+    expressions: Expression[];
+}
+interface SimpleCallExpression extends BaseCallExpression {
+    type: "CallExpression";
+    optional?: boolean;
+}
+interface SimpleLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value: string | boolean | number | null;
+    raw?: string | undefined;
+}
+interface SourceLocation {
+    source?: string | null | undefined;
+    start: Position;
+    end: Position;
+}
+interface SpreadElement extends BaseNode {
+    type: "SpreadElement";
+    argument: Expression;
+}
+interface SwitchCase extends BaseNode {
+    type: "SwitchCase";
+    test?: Expression | null | undefined;
+    consequent: Statement[];
+}
+interface SwitchStatement extends BaseStatement {
+    type: "SwitchStatement";
+    discriminant: Expression;
+    cases: SwitchCase[];
+}
+interface TaggedTemplateExpression extends BaseExpression {
+    type: "TaggedTemplateExpression";
+    tag: Expression;
+    quasi: TemplateLiteral;
+}
+interface TemplateElement extends BaseNode {
+    type: "TemplateElement";
+    tail: boolean;
+    value: {
+        cooked?: string | null | undefined;
+        raw: string;
+    };
+}
+interface TemplateLiteral extends BaseExpression {
+    type: "TemplateLiteral";
+    quasis: TemplateElement[];
+    expressions: Expression[];
+}
+interface ThisExpression extends BaseExpression {
+    type: "ThisExpression";
+}
+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 UnaryExpression extends BaseExpression {
+    type: "UnaryExpression";
+    operator: UnaryOperator;
+    prefix: true;
+    argument: Expression;
+}
+interface UpdateExpression extends BaseExpression {
+    type: "UpdateExpression";
+    operator: UpdateOperator;
+    argument: Expression;
+    prefix: boolean;
+}
+interface VariableDeclaration extends BaseDeclaration {
+    type: "VariableDeclaration";
+    declarations: VariableDeclarator[];
+    kind: "var" | "let" | "const";
+}
+interface VariableDeclarator extends BaseNode {
+    type: "VariableDeclarator";
+    id: Pattern;
+    init?: Expression | null | undefined;
+}
+interface WhileStatement extends BaseStatement {
+    type: "WhileStatement";
+    test: Expression;
+    body: Statement;
+}
+interface ImportDeclaration extends BaseModuleDeclaration {
+    type: "ImportDeclaration";
+    specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
+    source: Literal;
+}
+interface ImportSpecifier extends BaseModuleSpecifier {
+    type: "ImportSpecifier";
+    imported: Identifier;
+}
+interface ImportExpression extends BaseExpression {
+    type: "ImportExpression";
+    source: Expression;
+}
+interface ImportDefaultSpecifier extends BaseModuleSpecifier {
+    type: "ImportDefaultSpecifier";
+}
+interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
+    type: "ImportNamespaceSpecifier";
+}
+type SimpleArrayExpression = Partial<ArrayExpression>;
+type SimpleArrayPattern = Partial<ArrayPattern>;
+type SimpleArrowFunctionExpression = Partial<ArrowFunctionExpression>;
+type SimpleAssignmentExpression = Partial<AssignmentExpression>;
+type SimpleAssignmentPattern = Partial<AssignmentPattern>;
+type SimpleAssignmentProperty = Partial<AssignmentProperty>;
+type SimpleAwaitExpression = Partial<AwaitExpression>;
+type SimpleBaseCallExpression = Partial<BaseCallExpression>;
+type SimpleBaseDeclaration = Partial<BaseDeclaration>;
+type SimpleBaseExpression = Partial<BaseExpression>;
+type SimpleBaseForXStatement = Partial<BaseForXStatement>;
+type SimpleBaseFunction = Partial<BaseFunction>;
+type SimpleBaseNode = Partial<BaseNode>;
+type SimpleBaseNodeWithoutComments = Partial<BaseNodeWithoutComments>;
+type SimpleBasePattern = Partial<BasePattern>;
+type SimpleBaseStatement = Partial<BaseStatement>;
+type SimpleBigIntLiteral = Partial<BigIntLiteral>;
+type SimpleBinaryExpression = Partial<BinaryExpression>;
+type SimpleBlockStatement = Partial<BlockStatement>;
+type SimpleBreakStatement = Partial<BreakStatement>;
+type SimpleCatchClause = Partial<CatchClause>;
+type SimpleChainExpression = Partial<ChainExpression>;
+type SimpleComment = Partial<Comment>;
+type SimpleConditionalExpression = Partial<ConditionalExpression>;
+type SimpleContinueStatement = Partial<ContinueStatement>;
+type SimpleDoWhileStatement = Partial<DoWhileStatement>;
+type SimpleEmptyStatement = Partial<EmptyStatement>;
+type SimpleExpressionStatement = Partial<ExpressionStatement>;
+type SimpleForInStatement = Partial<ForInStatement>;
+type SimpleForOfStatement = Partial<ForOfStatement>;
+type SimpleForStatement = Partial<ForStatement>;
+type SimpleFunctionDeclaration = Partial<FunctionDeclaration>;
+type SimpleFunctionExpression = Partial<FunctionExpression>;
+type SimpleIdentifier = Partial<Identifier>;
+type SimpleIfStatement = Partial<IfStatement>;
+type SimpleJsonExpression = Partial<JsonExpression>;
+type SimpleLabeledStatement = Partial<LabeledStatement>;
+type SimpleLogicalExpression = Partial<LogicalExpression>;
+type SimpleMemberExpression = Partial<MemberExpression>;
+type SimpleMethodDefinition = Partial<MethodDefinition>;
+type SimpleNewExpression = Partial<NewExpression>;
+type SimpleObjectExpression = Partial<ObjectExpression>;
+type SimpleObjectPattern = Partial<ObjectPattern>;
+type SimplePosition = Partial<Position>;
+type SimpleProgram = Partial<Program>;
+type SimpleProperty = Partial<Property>;
+type SimplePropertyDefinition = Partial<PropertyDefinition>;
+type SimpleRegExpLiteral = Partial<RegExpLiteral>;
+type SimpleRestElement = Partial<RestElement>;
+type SimpleReturnStatement = Partial<ReturnStatement>;
+type SimpleSequenceExpression = Partial<SequenceExpression>;
+type SimpleSimpleCallExpression = Partial<SimpleCallExpression>;
+type SimpleSimpleLiteral = Partial<SimpleLiteral>;
+type SimpleSourceLocation = Partial<SourceLocation>;
+type SimpleSpreadElement = Partial<SpreadElement>;
+type SimpleSwitchCase = Partial<SwitchCase>;
+type SimpleSwitchStatement = Partial<SwitchStatement>;
+type SimpleTemplateElement = Partial<TemplateElement>;
+type SimpleTemplateLiteral = Partial<TemplateLiteral>;
+type SimpleThisExpression = Partial<ThisExpression>;
+type SimpleThrowStatement = Partial<ThrowStatement>;
+type SimpleTryStatement = Partial<TryStatement>;
+type SimpleUnaryExpression = Partial<UnaryExpression>;
+type SimpleUpdateExpression = Partial<UpdateExpression>;
+type SimpleVariableDeclaration = Partial<VariableDeclaration>;
+type SimpleVariableDeclarator = Partial<VariableDeclarator>;
+type SimpleWhileStatement = Partial<WhileStatement>;
+
+type types_ArrayExpression = ArrayExpression;
+type types_ArrayPattern = ArrayPattern;
+type types_ArrowFunctionExpression = ArrowFunctionExpression;
+type types_AssignmentExpression = AssignmentExpression;
+type types_AssignmentOperator = AssignmentOperator;
+type types_AssignmentPattern = AssignmentPattern;
+type types_AssignmentProperty = AssignmentProperty;
+type types_AwaitExpression = AwaitExpression;
+type types_BaseCallExpression = BaseCallExpression;
+type types_BaseDeclaration = BaseDeclaration;
+type types_BaseExpression = BaseExpression;
+type types_BaseForXStatement = BaseForXStatement;
+type types_BaseFunction = BaseFunction;
+type types_BaseModuleDeclaration = BaseModuleDeclaration;
+type types_BaseModuleSpecifier = BaseModuleSpecifier;
+type types_BaseNode = BaseNode;
+type types_BaseNodeWithoutComments = BaseNodeWithoutComments;
+type types_BasePattern = BasePattern;
+type types_BaseStatement = BaseStatement;
+type types_BigIntLiteral = BigIntLiteral;
+type types_BinaryExpression = BinaryExpression;
+type types_BinaryOperator = BinaryOperator;
+type types_BlockStatement = BlockStatement;
+type types_BreakStatement = BreakStatement;
+type types_CallExpression = CallExpression;
+type types_CatchClause = CatchClause;
+type types_ChainElement = ChainElement;
+type types_ChainExpression = ChainExpression;
+type types_Comment = Comment;
+type types_ConditionalExpression = ConditionalExpression;
+type types_ContinueStatement = ContinueStatement;
+type types_DebuggerStatement = DebuggerStatement;
+type types_Declaration = Declaration;
+type types_Directive = Directive;
+type types_DoWhileStatement = DoWhileStatement;
+type types_EmptyStatement = EmptyStatement;
+type types_Expression = Expression;
+type types_ExpressionStatement = ExpressionStatement;
+type types_ForInStatement = ForInStatement;
+type types_ForOfStatement = ForOfStatement;
+type types_ForStatement = ForStatement;
+type types_Function = Function;
+type types_FunctionDeclaration = FunctionDeclaration;
+type types_FunctionExpression = FunctionExpression;
+type types_Identifier = Identifier;
+type types_IfStatement = IfStatement;
+type types_ImportDeclaration = ImportDeclaration;
+type types_ImportDefaultSpecifier = ImportDefaultSpecifier;
+type types_ImportExpression = ImportExpression;
+type types_ImportNamespaceSpecifier = ImportNamespaceSpecifier;
+type types_ImportSpecifier = ImportSpecifier;
+type types_JsonExpression = JsonExpression;
+type types_LabeledStatement = LabeledStatement;
+type types_Literal = Literal;
+type types_LogicalExpression = LogicalExpression;
+type types_LogicalOperator = LogicalOperator;
+type types_MaybeNamedFunctionDeclaration = MaybeNamedFunctionDeclaration;
+type types_MemberExpression = MemberExpression;
+type types_MetaProperty = MetaProperty;
+type types_MethodDefinition = MethodDefinition;
+type types_ModuleDeclaration = ModuleDeclaration;
+type types_ModuleSpecifier = ModuleSpecifier;
+type types_NewExpression = NewExpression;
+type types_Node = Node;
+type types_NodeMap = NodeMap;
+type types_ObjectExpression = ObjectExpression;
+type types_ObjectPattern = ObjectPattern;
+type types_Pattern = Pattern;
+type types_Position = Position;
+type types_Program = Program;
+type types_Property = Property;
+type types_PropertyDefinition = PropertyDefinition;
+type types_RegExpLiteral = RegExpLiteral;
+type types_RestElement = RestElement;
+type types_ReturnStatement = ReturnStatement;
+type types_SequenceExpression = SequenceExpression;
+type types_SimpleArrayExpression = SimpleArrayExpression;
+type types_SimpleArrayPattern = SimpleArrayPattern;
+type types_SimpleArrowFunctionExpression = SimpleArrowFunctionExpression;
+type types_SimpleAssignmentExpression = SimpleAssignmentExpression;
+type types_SimpleAssignmentPattern = SimpleAssignmentPattern;
+type types_SimpleAssignmentProperty = SimpleAssignmentProperty;
+type types_SimpleAwaitExpression = SimpleAwaitExpression;
+type types_SimpleBaseCallExpression = SimpleBaseCallExpression;
+type types_SimpleBaseDeclaration = SimpleBaseDeclaration;
+type types_SimpleBaseExpression = SimpleBaseExpression;
+type types_SimpleBaseForXStatement = SimpleBaseForXStatement;
+type types_SimpleBaseFunction = SimpleBaseFunction;
+type types_SimpleBaseNode = SimpleBaseNode;
+type types_SimpleBaseNodeWithoutComments = SimpleBaseNodeWithoutComments;
+type types_SimpleBasePattern = SimpleBasePattern;
+type types_SimpleBaseStatement = SimpleBaseStatement;
+type types_SimpleBigIntLiteral = SimpleBigIntLiteral;
+type types_SimpleBinaryExpression = SimpleBinaryExpression;
+type types_SimpleBlockStatement = SimpleBlockStatement;
+type types_SimpleBreakStatement = SimpleBreakStatement;
+type types_SimpleCallExpression = SimpleCallExpression;
+type types_SimpleCatchClause = SimpleCatchClause;
+type types_SimpleChainExpression = SimpleChainExpression;
+type types_SimpleComment = SimpleComment;
+type types_SimpleConditionalExpression = SimpleConditionalExpression;
+type types_SimpleContinueStatement = SimpleContinueStatement;
+type types_SimpleDoWhileStatement = SimpleDoWhileStatement;
+type types_SimpleEmptyStatement = SimpleEmptyStatement;
+type types_SimpleExpressionStatement = SimpleExpressionStatement;
+type types_SimpleForInStatement = SimpleForInStatement;
+type types_SimpleForOfStatement = SimpleForOfStatement;
+type types_SimpleForStatement = SimpleForStatement;
+type types_SimpleFunctionDeclaration = SimpleFunctionDeclaration;
+type types_SimpleFunctionExpression = SimpleFunctionExpression;
+type types_SimpleIdentifier = SimpleIdentifier;
+type types_SimpleIfStatement = SimpleIfStatement;
+type types_SimpleJsonExpression = SimpleJsonExpression;
+type types_SimpleLabeledStatement = SimpleLabeledStatement;
+type types_SimpleLiteral = SimpleLiteral;
+type types_SimpleLogicalExpression = SimpleLogicalExpression;
+type types_SimpleMemberExpression = SimpleMemberExpression;
+type types_SimpleMethodDefinition = SimpleMethodDefinition;
+type types_SimpleNewExpression = SimpleNewExpression;
+type types_SimpleNode = SimpleNode;
+type types_SimpleObjectExpression = SimpleObjectExpression;
+type types_SimpleObjectPattern = SimpleObjectPattern;
+type types_SimplePosition = SimplePosition;
+type types_SimpleProgram = SimpleProgram;
+type types_SimpleProperty = SimpleProperty;
+type types_SimplePropertyDefinition = SimplePropertyDefinition;
+type types_SimpleRegExpLiteral = SimpleRegExpLiteral;
+type types_SimpleRestElement = SimpleRestElement;
+type types_SimpleReturnStatement = SimpleReturnStatement;
+type types_SimpleSequenceExpression = SimpleSequenceExpression;
+type types_SimpleSimpleCallExpression = SimpleSimpleCallExpression;
+type types_SimpleSimpleLiteral = SimpleSimpleLiteral;
+type types_SimpleSourceLocation = SimpleSourceLocation;
+type types_SimpleSpreadElement = SimpleSpreadElement;
+type types_SimpleSwitchCase = SimpleSwitchCase;
+type types_SimpleSwitchStatement = SimpleSwitchStatement;
+type types_SimpleTemplateElement = SimpleTemplateElement;
+type types_SimpleTemplateLiteral = SimpleTemplateLiteral;
+type types_SimpleThisExpression = SimpleThisExpression;
+type types_SimpleThrowStatement = SimpleThrowStatement;
+type types_SimpleTryStatement = SimpleTryStatement;
+type types_SimpleUnaryExpression = SimpleUnaryExpression;
+type types_SimpleUpdateExpression = SimpleUpdateExpression;
+type types_SimpleVariableDeclaration = SimpleVariableDeclaration;
+type types_SimpleVariableDeclarator = SimpleVariableDeclarator;
+type types_SimpleWhileStatement = SimpleWhileStatement;
+type types_SourceLocation = SourceLocation;
+type types_SpreadElement = SpreadElement;
+type types_Statement = Statement;
+type types_SwitchCase = SwitchCase;
+type types_SwitchStatement = SwitchStatement;
+type types_TSLite = TSLite;
+type types_TSLiteMarker = TSLiteMarker;
+type types_TaggedTemplateExpression = TaggedTemplateExpression;
+type types_TemplateElement = TemplateElement;
+type types_TemplateLiteral = TemplateLiteral;
+type types_ThisExpression = ThisExpression;
+type types_ThrowStatement = ThrowStatement;
+type types_TryStatement = TryStatement;
+type types_UnaryExpression = UnaryExpression;
+type types_UnaryOperator = UnaryOperator;
+type types_UpdateExpression = UpdateExpression;
+type types_UpdateOperator = UpdateOperator;
+type types_VariableDeclaration = VariableDeclaration;
+type types_VariableDeclarator = VariableDeclarator;
+type types_WhileStatement = WhileStatement;
+declare namespace types {
+  export type { types_ArrayExpression as ArrayExpression, types_ArrayPattern as ArrayPattern, types_ArrowFunctionExpression as ArrowFunctionExpression, types_AssignmentExpression as AssignmentExpression, types_AssignmentOperator as AssignmentOperator, types_AssignmentPattern as AssignmentPattern, types_AssignmentProperty as AssignmentProperty, types_AwaitExpression as AwaitExpression, types_BaseCallExpression as BaseCallExpression, types_BaseDeclaration as BaseDeclaration, types_BaseExpression as BaseExpression, types_BaseForXStatement as BaseForXStatement, types_BaseFunction as BaseFunction, types_BaseModuleDeclaration as BaseModuleDeclaration, types_BaseModuleSpecifier as BaseModuleSpecifier, types_BaseNode as BaseNode, types_BaseNodeWithoutComments as BaseNodeWithoutComments, types_BasePattern as BasePattern, types_BaseStatement as BaseStatement, types_BigIntLiteral as BigIntLiteral, types_BinaryExpression as BinaryExpression, types_BinaryOperator as BinaryOperator, types_BlockStatement as BlockStatement, types_BreakStatement as BreakStatement, types_CallExpression as CallExpression, types_CatchClause as CatchClause, types_ChainElement as ChainElement, types_ChainExpression as ChainExpression, types_Comment as Comment, types_ConditionalExpression as ConditionalExpression, types_ContinueStatement as ContinueStatement, types_DebuggerStatement as DebuggerStatement, types_Declaration as Declaration, types_Directive as Directive, types_DoWhileStatement as DoWhileStatement, types_EmptyStatement as EmptyStatement, types_Expression as Expression, types_ExpressionStatement as ExpressionStatement, types_ForInStatement as ForInStatement, types_ForOfStatement as ForOfStatement, types_ForStatement as ForStatement, types_Function as Function, types_FunctionDeclaration as FunctionDeclaration, types_FunctionExpression as FunctionExpression, types_Identifier as Identifier, types_IfStatement as IfStatement, types_ImportDeclaration as ImportDeclaration, types_ImportDefaultSpecifier as ImportDefaultSpecifier, types_ImportExpression as ImportExpression, types_ImportNamespaceSpecifier as ImportNamespaceSpecifier, types_ImportSpecifier as ImportSpecifier, types_JsonExpression as JsonExpression, types_LabeledStatement as LabeledStatement, types_Literal as Literal, types_LogicalExpression as LogicalExpression, types_LogicalOperator as LogicalOperator, types_MaybeNamedFunctionDeclaration as MaybeNamedFunctionDeclaration, types_MemberExpression as MemberExpression, types_MetaProperty as MetaProperty, types_MethodDefinition as MethodDefinition, types_ModuleDeclaration as ModuleDeclaration, types_ModuleSpecifier as ModuleSpecifier, types_NewExpression as NewExpression, types_Node as Node, types_NodeMap as NodeMap, types_ObjectExpression as ObjectExpression, types_ObjectPattern as ObjectPattern, types_Pattern as Pattern, types_Position as Position, types_Program as Program, types_Property as Property, types_PropertyDefinition as PropertyDefinition, types_RegExpLiteral as RegExpLiteral, types_RestElement as RestElement, types_ReturnStatement as ReturnStatement, types_SequenceExpression as SequenceExpression, types_SimpleArrayExpression as SimpleArrayExpression, types_SimpleArrayPattern as SimpleArrayPattern, types_SimpleArrowFunctionExpression as SimpleArrowFunctionExpression, types_SimpleAssignmentExpression as SimpleAssignmentExpression, types_SimpleAssignmentPattern as SimpleAssignmentPattern, types_SimpleAssignmentProperty as SimpleAssignmentProperty, types_SimpleAwaitExpression as SimpleAwaitExpression, types_SimpleBaseCallExpression as SimpleBaseCallExpression, types_SimpleBaseDeclaration as SimpleBaseDeclaration, types_SimpleBaseExpression as SimpleBaseExpression, types_SimpleBaseForXStatement as SimpleBaseForXStatement, types_SimpleBaseFunction as SimpleBaseFunction, types_SimpleBaseNode as SimpleBaseNode, types_SimpleBaseNodeWithoutComments as SimpleBaseNodeWithoutComments, types_SimpleBasePattern as SimpleBasePattern, types_SimpleBaseStatement as SimpleBaseStatement, types_SimpleBigIntLiteral as SimpleBigIntLiteral, types_SimpleBinaryExpression as SimpleBinaryExpression, types_SimpleBlockStatement as SimpleBlockStatement, types_SimpleBreakStatement as SimpleBreakStatement, types_SimpleCallExpression as SimpleCallExpression, types_SimpleCatchClause as SimpleCatchClause, types_SimpleChainExpression as SimpleChainExpression, types_SimpleComment as SimpleComment, types_SimpleConditionalExpression as SimpleConditionalExpression, types_SimpleContinueStatement as SimpleContinueStatement, types_SimpleDoWhileStatement as SimpleDoWhileStatement, types_SimpleEmptyStatement as SimpleEmptyStatement, types_SimpleExpressionStatement as SimpleExpressionStatement, types_SimpleForInStatement as SimpleForInStatement, types_SimpleForOfStatement as SimpleForOfStatement, types_SimpleForStatement as SimpleForStatement, types_SimpleFunctionDeclaration as SimpleFunctionDeclaration, types_SimpleFunctionExpression as SimpleFunctionExpression, types_SimpleIdentifier as SimpleIdentifier, types_SimpleIfStatement as SimpleIfStatement, types_SimpleJsonExpression as SimpleJsonExpression, types_SimpleLabeledStatement as SimpleLabeledStatement, types_SimpleLiteral as SimpleLiteral, types_SimpleLogicalExpression as SimpleLogicalExpression, types_SimpleMemberExpression as SimpleMemberExpression, types_SimpleMethodDefinition as SimpleMethodDefinition, types_SimpleNewExpression as SimpleNewExpression, types_SimpleNode as SimpleNode, types_SimpleObjectExpression as SimpleObjectExpression, types_SimpleObjectPattern as SimpleObjectPattern, types_SimplePosition as SimplePosition, types_SimpleProgram as SimpleProgram, types_SimpleProperty as SimpleProperty, types_SimplePropertyDefinition as SimplePropertyDefinition, types_SimpleRegExpLiteral as SimpleRegExpLiteral, types_SimpleRestElement as SimpleRestElement, types_SimpleReturnStatement as SimpleReturnStatement, types_SimpleSequenceExpression as SimpleSequenceExpression, types_SimpleSimpleCallExpression as SimpleSimpleCallExpression, types_SimpleSimpleLiteral as SimpleSimpleLiteral, types_SimpleSourceLocation as SimpleSourceLocation, types_SimpleSpreadElement as SimpleSpreadElement, types_SimpleSwitchCase as SimpleSwitchCase, types_SimpleSwitchStatement as SimpleSwitchStatement, types_SimpleTemplateElement as SimpleTemplateElement, types_SimpleTemplateLiteral as SimpleTemplateLiteral, types_SimpleThisExpression as SimpleThisExpression, types_SimpleThrowStatement as SimpleThrowStatement, types_SimpleTryStatement as SimpleTryStatement, types_SimpleUnaryExpression as SimpleUnaryExpression, types_SimpleUpdateExpression as SimpleUpdateExpression, types_SimpleVariableDeclaration as SimpleVariableDeclaration, types_SimpleVariableDeclarator as SimpleVariableDeclarator, types_SimpleWhileStatement as SimpleWhileStatement, types_SourceLocation as SourceLocation, types_SpreadElement as SpreadElement, types_Statement as Statement, types_SwitchCase as SwitchCase, types_SwitchStatement as SwitchStatement, types_TSLite as TSLite, types_TSLiteMarker as TSLiteMarker, types_TaggedTemplateExpression as TaggedTemplateExpression, types_TemplateElement as TemplateElement, types_TemplateLiteral as TemplateLiteral, types_ThisExpression as ThisExpression, types_ThrowStatement as ThrowStatement, types_TryStatement as TryStatement, types_UnaryExpression as UnaryExpression, types_UnaryOperator as UnaryOperator, types_UpdateExpression as UpdateExpression, types_UpdateOperator as UpdateOperator, types_VariableDeclaration as VariableDeclaration, types_VariableDeclarator as VariableDeclarator, types_WhileStatement as WhileStatement };
+}
+
+/** Erro lançado pelo `@tslite/core`. */
+type CoreErrorCode = "invalid-ast-entry" | "missing-node-type" | "unknown-node-type";
+/**
+ * Erro base da plataforma TSLite. Carrega um `code` legível por máquina e um
+ * `details` opcional com o contexto estruturado (ex.: o `type` ofensor).
+ *
+ * @typeParam C - união de codes do package que lança; default `string`.
+ */
+declare class TSLiteError<C extends string = string> extends Error {
+    readonly code: C;
+    readonly details?: Record<string, unknown>;
+    constructor(code: C, message: string, details?: Record<string, unknown>);
+}
+
+/** Marker para lógica executável em JSON híbrido */
+declare const AST_MARKER = "#ast";
+/** Pattern para keys de objeto válidas sem aspas */
+declare const VALID_OBJECT_KEY: RegExp;
+/**
+ * Tipos válidos como ponto de entrada #ast.
+ *
+ * São tipos que podem aparecer como VALOR em JSON - tudo que pode estar
+ * do lado direito de uma atribuição ou como valor de propriedade.
+ *
+ * Basicamente: Expressions + Program (para AST completo)
+ */
+declare const VALID_AST_ENTRY_TYPES: readonly ["Identifier", "MemberExpression", "CallExpression", "ArrowFunctionExpression", "FunctionExpression", "BinaryExpression", "LogicalExpression", "UnaryExpression", "UpdateExpression", "ConditionalExpression", "AssignmentExpression", "NewExpression", "ArrayExpression", "ObjectExpression", "AwaitExpression", "TemplateLiteral", "TaggedTemplateExpression", "SequenceExpression", "ChainExpression", "Program"];
+type ValidAstEntryType = (typeof VALID_AST_ENTRY_TYPES)[number];
+/**
+ * Verifica se um tipo é válido como ponto de entrada #ast
+ */
+declare function isValidAstEntryType(type: string): type is ValidAstEntryType;
+/**
+ * Erro para tipo inválido como entrada #ast.
+ *
+ * `code: "invalid-ast-entry"`; `details` carrega o `type` ofensor e a lista de
+ * tipos válidos, para o consumidor reagir sem fazer parse da mensagem.
+ */
+declare function invalidAstEntryError(type: string): TSLiteError<"invalid-ast-entry">;
+declare const VisitorKeys: {
+    AssignmentExpression: string[];
+    AssignmentPattern: string[];
+    ArrayExpression: string[];
+    ArrayPattern: string[];
+    ArrowFunctionExpression: string[];
+    AwaitExpression: string[];
+    BlockStatement: string[];
+    BinaryExpression: string[];
+    BreakStatement: string[];
+    CallExpression: string[];
+    CatchClause: string[];
+    ChainExpression: string[];
+    ClassBody: string[];
+    ClassDeclaration: string[];
+    ClassExpression: string[];
+    ConditionalExpression: string[];
+    ContinueStatement: string[];
+    DebuggerStatement: never[];
+    DirectiveStatement: never[];
+    DoWhileStatement: string[];
+    EmptyStatement: never[];
+    ExpressionStatement: string[];
+    ForStatement: string[];
+    ForInStatement: string[];
+    ForOfStatement: string[];
+    FunctionDeclaration: string[];
+    FunctionExpression: string[];
+    Identifier: never[];
+    IfStatement: string[];
+    ImportDeclaration: string[];
+    ImportDefaultSpecifier: string[];
+    ImportExpression: string[];
+    ImportNamespaceSpecifier: string[];
+    ImportSpecifier: string[];
+    JsonExpression: never[];
+    Literal: never[];
+    LabeledStatement: string[];
+    LogicalExpression: string[];
+    MemberExpression: string[];
+    MetaProperty: string[];
+    MethodDefinition: string[];
+    ModuleSpecifier: never[];
+    NewExpression: string[];
+    ObjectExpression: string[];
+    ObjectPattern: string[];
+    PrivateIdentifier: never[];
+    Program: string[];
+    Property: string[];
+    PropertyDefinition: string[];
+    RestElement: string[];
+    ReturnStatement: string[];
+    SequenceExpression: string[];
+    SpreadElement: string[];
+    SwitchStatement: string[];
+    SwitchCase: string[];
+    TaggedTemplateExpression: string[];
+    TemplateElement: never[];
+    TemplateLiteral: string[];
+    ThisExpression: never[];
+    ThrowStatement: string[];
+    TryStatement: string[];
+    UnaryExpression: string[];
+    UpdateExpression: string[];
+    VariableDeclaration: string[];
+    VariableDeclarator: string[];
+    WhileStatement: string[];
+    WithStatement: string[];
+};
+declare const Precedence: {
+    Sequence: number;
+    Yield: number;
+    Assignment: number;
+    Conditional: number;
+    ArrowFunction: number;
+    Coalesce: number;
+    LogicalOR: number;
+    LogicalAND: number;
+    BitwiseOR: number;
+    BitwiseXOR: number;
+    BitwiseAND: number;
+    Equality: number;
+    Relational: number;
+    BitwiseSHIFT: number;
+    Additive: number;
+    Multiplicative: number;
+    Exponentiation: number;
+    Await: number;
+    Unary: number;
+    Postfix: number;
+    OptionalChaining: number;
+    Call: number;
+    New: number;
+    TaggedTemplate: number;
+    Member: number;
+    Primary: number;
+};
+declare const BinaryPrecedence: {
+    "??": number;
+    "||": number;
+    "&&": number;
+    "|": number;
+    "^": number;
+    "&": number;
+    "==": number;
+    "!=": number;
+    "===": number;
+    "!==": number;
+    is: number;
+    isnt: number;
+    "<": number;
+    ">": number;
+    "<=": number;
+    ">=": number;
+    in: number;
+    instanceof: number;
+    "<<": number;
+    ">>": number;
+    ">>>": number;
+    "+": number;
+    "-": number;
+    "*": number;
+    "%": number;
+    "/": number;
+    "**": number;
+};
+
+/**
+ * Cria um marcador #ast para embedar AST em JSON.
+ *
+ * O formato usa #ast como o tipo do nó, sem wrapper body:
+ * ```
+ * { "#ast": "CallExpression", "callee": {...}, "arguments": [] }
+ * ```
+ *
+ * @param node - Nó AST (deve ter propriedade `type`)
+ * @returns Objeto com #ast marker pronto para JSON
+ * @throws Se o tipo não for válido como entry point
+ */
+declare const ast: (node: Node) => TSLiteMarker;
+/**
+ * Converte um objeto com #ast marker de volta para nó AST com type.
+ *
+ * Útil quando você tem um objeto no formato TSLite e precisa usar como nó AST
+ * normal (ex: passar como argumento).
+ *
+ * @param obj - Objeto com #ast marker
+ * @returns Nó AST com type (ou o objeto original se não tiver #ast)
+ *
+ * @example
+ * ```ts
+ * const astMarked = { "#ast": "Identifier", name: "foo" };
+ * const node = fromAstMarker(astMarked);
+ * // { type: "Identifier", name: "foo" }
+ * ```
+ */
+declare const fromAstMarker: (obj: unknown) => unknown;
+declare const identifier: (name: string) => Identifier;
+declare const literal: (value: string | boolean | number | null | RegExp | bigint | undefined) => Literal;
+declare const arrayExpression: (elements: Array<Expression | SpreadElement | null>) => ArrayExpression;
+declare const objectExpression: (properties: Array<Property | SpreadElement>) => ObjectExpression;
+declare const property: (key: Expression, value: Expression | Pattern | AssignmentProperty, shorthand?: boolean, computed?: boolean) => Property;
+declare const spreadElement: (argument: Expression) => SpreadElement;
+declare const callExpression: (callee: Expression, args: Array<Expression | SpreadElement>, optional?: boolean) => SimpleCallExpression;
+declare const newExpression: (callee: Expression, args: Array<Expression | SpreadElement>) => NewExpression;
+declare const memberExpression: (object: Expression, property: Expression, computed?: boolean, optional?: boolean) => MemberExpression;
+declare const chainExpression: (expression: ChainElement) => ChainExpression;
+declare const binaryExpression: (operator: BinaryOperator, left: Expression, right: Expression) => BinaryExpression;
+declare const logicalExpression: (operator: LogicalOperator, left: Expression, right: Expression) => LogicalExpression;
+declare const unaryExpression: (operator: UnaryOperator, argument: Expression) => UnaryExpression;
+declare const updateExpression: (operator: UpdateOperator, argument: Expression, prefix?: boolean) => UpdateExpression;
+declare const assignmentExpression: (operator: AssignmentOperator, left: Pattern, right: Expression) => AssignmentExpression;
+declare const conditionalExpression: (test: Expression, consequent: Expression, alternate: Expression) => ConditionalExpression;
+declare const awaitExpression: (argument: Expression | null) => AwaitExpression;
+declare const templateElement: (value: {
+    cooked?: string | null | undefined;
+    raw: string;
+}, tail?: boolean) => TemplateElement;
+declare const templateLiteral: (quasis: TemplateElement[], expressions: Expression[]) => TemplateLiteral;
+declare const arrowFunctionExpression: (params: Pattern[], body: Expression | BlockStatement, async?: boolean, generator?: boolean) => ArrowFunctionExpression;
+declare const functionExpression: (id: Identifier | null | undefined, params: Pattern[], body: BlockStatement, async?: boolean, generator?: boolean) => FunctionExpression;
+declare const functionDeclaration: (id: Identifier, params: Pattern[], body: BlockStatement, generator?: boolean, async?: boolean) => FunctionDeclaration;
+declare const blockStatement: (body: Statement[]) => BlockStatement;
+declare const expressionStatement: (expression: Expression) => ExpressionStatement;
+declare const returnStatement: (argument: Expression | null | undefined) => ReturnStatement;
+declare const ifStatement: (test: Expression, consequent: Statement, alternate?: Statement | null | undefined) => IfStatement;
+declare const switchStatement: (discriminant: Expression, cases: SwitchCase[]) => SwitchStatement;
+declare const switchCase: (test: Expression | null | undefined, consequent: Statement[]) => SwitchCase;
+declare const throwStatement: (argument: Expression) => ThrowStatement;
+declare const tryStatement: (block: BlockStatement, handler: CatchClause | null | undefined, finalizer?: BlockStatement | null | undefined) => TryStatement;
+declare const catchClause: (param: Pattern | null, body: BlockStatement) => CatchClause;
+declare const breakStatement: (label?: Identifier | null) => BreakStatement;
+declare const continueStatement: (label?: Identifier | null) => ContinueStatement;
+declare const emptyStatement: () => EmptyStatement;
+declare const forStatement: (init: VariableDeclaration | Expression | null | undefined, test: Expression | null | undefined, update: Expression | null | undefined, body: Statement) => ForStatement;
+declare const forInStatement: (left: Pattern | VariableDeclaration, right: Expression, body: Statement) => ForInStatement;
+declare const forOfStatement: (left: Pattern | VariableDeclaration, right: Expression, body: Statement, _await?: boolean) => ForOfStatement;
+declare const whileStatement: (test: Expression, body: Statement) => WhileStatement;
+declare const doWhileStatement: (body: Statement, test: Expression) => DoWhileStatement;
+declare const variableDeclaration: (kind: "var" | "let" | "const", declarations: VariableDeclarator[]) => VariableDeclaration;
+declare const variableDeclarator: (id: Pattern, init?: Expression | null) => VariableDeclarator;
+declare const objectPattern: (properties: Array<AssignmentProperty | RestElement>) => ObjectPattern;
+declare const arrayPattern: (elements: Array<Pattern | null>) => ArrayPattern;
+declare const assignmentProperty: (key: Expression, value?: Pattern, shorthand?: boolean, computed?: boolean) => AssignmentProperty;
+declare const restElement: (argument: Pattern) => RestElement;
+declare const program: (body: Array<Directive | Statement | ModuleDeclaration>, sourceType?: "script" | "module") => Program;
+declare const jsonExpression: (body: TSLite) => JsonExpression;
+declare const importDeclaration: (specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>, source: Literal) => ImportDeclaration;
+declare const importSpecifier: (imported: Identifier, local: Identifier) => ImportSpecifier;
+declare const importDefaultSpecifier: (local: Identifier) => ImportDefaultSpecifier;
+declare const importNamespaceSpecifier: (local: Identifier) => ImportNamespaceSpecifier;
+declare const json: (body: TSLite) => JsonExpression;
+
+declare const index$1_arrayExpression: typeof arrayExpression;
+declare const index$1_arrayPattern: typeof arrayPattern;
+declare const index$1_arrowFunctionExpression: typeof arrowFunctionExpression;
+declare const index$1_assignmentExpression: typeof assignmentExpression;
+declare const index$1_assignmentProperty: typeof assignmentProperty;
+declare const index$1_ast: typeof ast;
+declare const index$1_awaitExpression: typeof awaitExpression;
+declare const index$1_binaryExpression: typeof binaryExpression;
+declare const index$1_blockStatement: typeof blockStatement;
+declare const index$1_breakStatement: typeof breakStatement;
+declare const index$1_callExpression: typeof callExpression;
+declare const index$1_catchClause: typeof catchClause;
+declare const index$1_chainExpression: typeof chainExpression;
+declare const index$1_conditionalExpression: typeof conditionalExpression;
+declare const index$1_continueStatement: typeof continueStatement;
+declare const index$1_doWhileStatement: typeof doWhileStatement;
+declare const index$1_emptyStatement: typeof emptyStatement;
+declare const index$1_expressionStatement: typeof expressionStatement;
+declare const index$1_forInStatement: typeof forInStatement;
+declare const index$1_forOfStatement: typeof forOfStatement;
+declare const index$1_forStatement: typeof forStatement;
+declare const index$1_fromAstMarker: typeof fromAstMarker;
+declare const index$1_functionDeclaration: typeof functionDeclaration;
+declare const index$1_functionExpression: typeof functionExpression;
+declare const index$1_identifier: typeof identifier;
+declare const index$1_ifStatement: typeof ifStatement;
+declare const index$1_importDeclaration: typeof importDeclaration;
+declare const index$1_importDefaultSpecifier: typeof importDefaultSpecifier;
+declare const index$1_importNamespaceSpecifier: typeof importNamespaceSpecifier;
+declare const index$1_importSpecifier: typeof importSpecifier;
+declare const index$1_json: typeof json;
+declare const index$1_jsonExpression: typeof jsonExpression;
+declare const index$1_literal: typeof literal;
+declare const index$1_logicalExpression: typeof logicalExpression;
+declare const index$1_memberExpression: typeof memberExpression;
+declare const index$1_newExpression: typeof newExpression;
+declare const index$1_objectExpression: typeof objectExpression;
+declare const index$1_objectPattern: typeof objectPattern;
+declare const index$1_program: typeof program;
+declare const index$1_property: typeof property;
+declare const index$1_restElement: typeof restElement;
+declare const index$1_returnStatement: typeof returnStatement;
+declare const index$1_spreadElement: typeof spreadElement;
+declare const index$1_switchCase: typeof switchCase;
+declare const index$1_switchStatement: typeof switchStatement;
+declare const index$1_templateElement: typeof templateElement;
+declare const index$1_templateLiteral: typeof templateLiteral;
+declare const index$1_throwStatement: typeof throwStatement;
+declare const index$1_tryStatement: typeof tryStatement;
+declare const index$1_unaryExpression: typeof unaryExpression;
+declare const index$1_updateExpression: typeof updateExpression;
+declare const index$1_variableDeclaration: typeof variableDeclaration;
+declare const index$1_variableDeclarator: typeof variableDeclarator;
+declare const index$1_whileStatement: typeof whileStatement;
+declare namespace index$1 {
+  export { index$1_arrayExpression as arrayExpression, index$1_arrayPattern as arrayPattern, index$1_arrowFunctionExpression as arrowFunctionExpression, index$1_assignmentExpression as assignmentExpression, index$1_assignmentProperty as assignmentProperty, index$1_ast as ast, index$1_awaitExpression as awaitExpression, index$1_binaryExpression as binaryExpression, index$1_blockStatement as blockStatement, index$1_breakStatement as breakStatement, index$1_callExpression as callExpression, index$1_catchClause as catchClause, index$1_chainExpression as chainExpression, index$1_conditionalExpression as conditionalExpression, index$1_continueStatement as continueStatement, index$1_doWhileStatement as doWhileStatement, index$1_emptyStatement as emptyStatement, index$1_expressionStatement as expressionStatement, index$1_forInStatement as forInStatement, index$1_forOfStatement as forOfStatement, index$1_forStatement as forStatement, index$1_fromAstMarker as fromAstMarker, index$1_functionDeclaration as functionDeclaration, index$1_functionExpression as functionExpression, index$1_identifier as identifier, index$1_ifStatement as ifStatement, index$1_importDeclaration as importDeclaration, index$1_importDefaultSpecifier as importDefaultSpecifier, index$1_importNamespaceSpecifier as importNamespaceSpecifier, index$1_importSpecifier as importSpecifier, index$1_json as json, index$1_jsonExpression as jsonExpression, index$1_literal as literal, index$1_logicalExpression as logicalExpression, index$1_memberExpression as memberExpression, index$1_newExpression as newExpression, index$1_objectExpression as objectExpression, index$1_objectPattern as objectPattern, index$1_program as program, index$1_property as property, index$1_restElement as restElement, index$1_returnStatement as returnStatement, index$1_spreadElement as spreadElement, index$1_switchCase as switchCase, index$1_switchStatement as switchStatement, index$1_templateElement as templateElement, index$1_templateLiteral as templateLiteral, index$1_throwStatement as throwStatement, index$1_tryStatement as tryStatement, index$1_unaryExpression as unaryExpression, index$1_updateExpression as updateExpression, index$1_variableDeclaration as variableDeclaration, index$1_variableDeclarator as variableDeclarator, index$1_whileStatement as whileStatement };
+}
+
+declare const generateBuilders: (prefix?: string) => {
+    build: (node: BaseNode, parent?: BaseNode) => any;
+    buildFunction: (node: BaseNode) => string;
+    safeEval: (codeJs: string) => any;
+    builders: {
+        ArrayExpression: (n: ArrayExpression, _parent: Node) => string;
+        ArrayPattern: (n: ArrayPattern, _parent: Node) => string;
+        ArrowFunctionExpression: (n: ArrowFunctionExpression, _parent: Node) => string;
+        AssignmentExpression: (n: AssignmentExpression, _parent: Node) => string;
+        AssignmentProperty: (n: AssignmentProperty, _parent: Node) => string;
+        AwaitExpression: (n: AwaitExpression, _parent: Node) => string;
+        BinaryExpression: (n: BinaryExpression, _parent: Node) => string;
+        BlockStatement: (n: BlockStatement, _parent: Node) => string;
+        BreakStatement: (n: BreakStatement, _parent: Node) => string;
+        CallExpression: (n: SimpleCallExpression, _parent: Node) => string;
+        CatchClause: (n: CatchClause, _parent: Node) => string;
+        ChainExpression: (n: ChainExpression, _parent: Node) => string;
+        ConditionalExpression: (n: ConditionalExpression, _parent: Node) => string;
+        ContinueStatement: (n: ContinueStatement, _parent: Node) => string;
+        DoWhileStatement: (n: DoWhileStatement, _parent: Node) => string;
+        EmptyStatement: (n: EmptyStatement, _parent: Node) => string;
+        ExpressionStatement: (n: ExpressionStatement, _parent: Node) => string;
+        ForInStatement: (n: ForInStatement, _parent: Node) => string;
+        ForOfStatement: (n: ForOfStatement, _parent: Node) => string;
+        ForStatement: (n: ForStatement, _parent: Node) => string;
+        FunctionDeclaration: (n: FunctionDeclaration, _parent: Node) => string;
+        FunctionExpression: (n: FunctionExpression, _parent: Node) => string;
+        Identifier: (n: Identifier, _parent: Node) => string;
+        IfStatement: (n: IfStatement, _parent: Node) => string;
+        ImportDeclaration: (n: ImportDeclaration, _parent: Node) => string;
+        ImportDefaultSpecifier: (n: ImportDefaultSpecifier, _parent: Node) => string;
+        ImportNamespaceSpecifier: (n: ImportNamespaceSpecifier, _parent: Node) => string;
+        ImportSpecifier: (n: ImportSpecifier, _parent: Node) => string;
+        JsonExpression: (n: JsonExpression, _parent: Node) => string;
+        Literal: (n: Literal, _parent: Node) => string;
+        LogicalExpression: (n: LogicalExpression, _parent: Node) => string;
+        MemberExpression: (n: MemberExpression, _parent: Node) => string;
+        NewExpression: (n: NewExpression, _parent: Node) => string;
+        ObjectExpression: (n: ObjectExpression, _parent: Node) => string;
+        ObjectPattern: (n: ObjectPattern, _parent: Node) => string;
+        Program: (n: Program, _parent: Node) => string;
+        Property: (n: Property, parent: ObjectExpression | ObjectPattern) => string | undefined;
+        ReturnStatement: (n: ReturnStatement, _parent: Node) => string;
+        SwitchCase: (n: SwitchCase, _parent: Node) => string;
+        SwitchStatement: (n: SwitchStatement, _parent: Node) => string;
+        TemplateElement: (n: TemplateElement, _parent: Node) => string;
+        TemplateLiteral: (n: TemplateLiteral, _parent: Node) => string;
+        ThrowStatement: (n: ThrowStatement, _parent: Node) => string;
+        TryStatement: (n: TryStatement, _parent: Node) => string;
+        UnaryExpression: (n: UnaryExpression, _parent: Node) => string;
+        UpdateExpression: (n: UpdateExpression, _parent: Node) => string;
+        VariableDeclaration: (n: VariableDeclaration, _parent: Node) => string;
+        VariableDeclarator: (n: VariableDeclarator, _parent: Node) => string;
+        WhileStatement: (n: WhileStatement, _parent: Node) => string;
+        SpreadElement: (n: SpreadElement, _parent: Node) => string;
+        RestElement: (n: RestElement, _parent: Node) => string;
+    };
+};
+
+declare const isLiteral: (n: any) => n is Literal;
+declare const isIdentifier: (n: any) => n is Identifier;
+declare const isBinaryExpression: (n: any) => n is BinaryExpression;
+declare const isArrowFunctionExpression: (n: any) => n is ArrowFunctionExpression;
+declare const isFunctionExpression: (n: any) => n is FunctionExpression;
+declare const isCallExpression: (n: any) => n is SimpleCallExpression;
+declare const isObjectExpression: (n: any) => n is ObjectExpression;
+declare const isArrayExpression: (n: any) => n is ArrayExpression;
+declare const isConditionalExpression: (n: any) => n is ConditionalExpression;
+declare const isLogicalExpression: (n: any) => n is LogicalExpression;
+declare const isUnaryExpression: (n: any) => n is UnaryExpression;
+declare const isUpdateExpression: (n: any) => n is UpdateExpression;
+declare const isMemberExpression: (n: any) => n is MemberExpression;
+declare const isAssignmentExpression: (n: any) => n is AssignmentExpression;
+declare const isAwaitExpression: (n: any) => n is AwaitExpression;
+declare const isNewExpression: (n: any) => n is NewExpression;
+declare const isJsonExpression: (n: any) => n is JsonExpression;
+declare const isExpressionStatement: (n: any) => n is ExpressionStatement;
+declare const isBlockStatement: (n: any) => n is BlockStatement;
+declare const isReturnStatement: (n: any) => n is ReturnStatement;
+declare const isIfStatement: (n: any) => n is IfStatement;
+declare const isBreakStatement: (n: any) => n is BreakStatement;
+declare const isContinueStatement: (n: any) => n is ContinueStatement;
+declare const isEmptyStatement: (n: any) => n is EmptyStatement;
+declare const isVariableDeclarator: (n: any) => n is VariableDeclarator;
+declare const isVariableDeclaration: (n: any) => n is VariableDeclaration;
+declare const isObjectPattern: (n: any) => n is ObjectPattern;
+declare const isArrayPattern: (n: any) => n is ArrayPattern;
+declare const isFunctionDeclaration: (n: any) => n is FunctionDeclaration;
+declare const isProgram: (n: any) => n is Program;
+declare const isSwitchStatement: (n: any) => n is SwitchStatement;
+declare const isSwitchCase: (n: any) => n is SwitchCase;
+declare const isWhileStatement: (n: any) => n is WhileStatement;
+declare const isForStatement: (n: any) => n is ForStatement;
+declare const isForInStatement: (n: any) => n is ForInStatement;
+declare const isForOfStatement: (n: any) => n is ForOfStatement;
+declare const isDoWhileStatement: (n: any) => n is DoWhileStatement;
+declare const isTryStatement: (n: any) => n is TryStatement;
+declare const isCatchClause: (n: any) => n is CatchClause;
+declare const isThrowStatement: (n: any) => n is ThrowStatement;
+declare const isTemplateElement: (n: any) => n is TemplateElement;
+declare const isTemplateLiteral: (n: any) => n is TemplateLiteral;
+declare const isImportDeclaration: (n: any) => n is ImportDeclaration;
+declare const isImportSpecifier: (n: any) => n is ImportSpecifier;
+declare const isImportDefaultSpecifier: (n: any) => n is ImportDefaultSpecifier;
+declare const isImportNamespaceSpecifier: (n: any) => n is ImportNamespaceSpecifier;
+declare const isModuleDeclaration: (n: any) => n is ModuleDeclaration;
+declare const isDirective: (n: any) => n is Directive;
+declare const isProperty: (n: any) => n is Property;
+declare const isAssignmentProperty: (n: any) => n is AssignmentProperty;
+declare const isNode: (n: any) => n is Node;
+
+declare const index_isArrayExpression: typeof isArrayExpression;
+declare const index_isArrayPattern: typeof isArrayPattern;
+declare const index_isArrowFunctionExpression: typeof isArrowFunctionExpression;
+declare const index_isAssignmentExpression: typeof isAssignmentExpression;
+declare const index_isAssignmentProperty: typeof isAssignmentProperty;
+declare const index_isAwaitExpression: typeof isAwaitExpression;
+declare const index_isBinaryExpression: typeof isBinaryExpression;
+declare const index_isBlockStatement: typeof isBlockStatement;
+declare const index_isBreakStatement: typeof isBreakStatement;
+declare const index_isCallExpression: typeof isCallExpression;
+declare const index_isCatchClause: typeof isCatchClause;
+declare const index_isConditionalExpression: typeof isConditionalExpression;
+declare const index_isContinueStatement: typeof isContinueStatement;
+declare const index_isDirective: typeof isDirective;
+declare const index_isDoWhileStatement: typeof isDoWhileStatement;
+declare const index_isEmptyStatement: typeof isEmptyStatement;
+declare const index_isExpressionStatement: typeof isExpressionStatement;
+declare const index_isForInStatement: typeof isForInStatement;
+declare const index_isForOfStatement: typeof isForOfStatement;
+declare const index_isForStatement: typeof isForStatement;
+declare const index_isFunctionDeclaration: typeof isFunctionDeclaration;
+declare const index_isFunctionExpression: typeof isFunctionExpression;
+declare const index_isIdentifier: typeof isIdentifier;
+declare const index_isIfStatement: typeof isIfStatement;
+declare const index_isImportDeclaration: typeof isImportDeclaration;
+declare const index_isImportDefaultSpecifier: typeof isImportDefaultSpecifier;
+declare const index_isImportNamespaceSpecifier: typeof isImportNamespaceSpecifier;
+declare const index_isImportSpecifier: typeof isImportSpecifier;
+declare const index_isJsonExpression: typeof isJsonExpression;
+declare const index_isLiteral: typeof isLiteral;
+declare const index_isLogicalExpression: typeof isLogicalExpression;
+declare const index_isMemberExpression: typeof isMemberExpression;
+declare const index_isModuleDeclaration: typeof isModuleDeclaration;
+declare const index_isNewExpression: typeof isNewExpression;
+declare const index_isNode: typeof isNode;
+declare const index_isObjectExpression: typeof isObjectExpression;
+declare const index_isObjectPattern: typeof isObjectPattern;
+declare const index_isProgram: typeof isProgram;
+declare const index_isProperty: typeof isProperty;
+declare const index_isReturnStatement: typeof isReturnStatement;
+declare const index_isSwitchCase: typeof isSwitchCase;
+declare const index_isSwitchStatement: typeof isSwitchStatement;
+declare const index_isTemplateElement: typeof isTemplateElement;
+declare const index_isTemplateLiteral: typeof isTemplateLiteral;
+declare const index_isThrowStatement: typeof isThrowStatement;
+declare const index_isTryStatement: typeof isTryStatement;
+declare const index_isUnaryExpression: typeof isUnaryExpression;
+declare const index_isUpdateExpression: typeof isUpdateExpression;
+declare const index_isVariableDeclaration: typeof isVariableDeclaration;
+declare const index_isVariableDeclarator: typeof isVariableDeclarator;
+declare const index_isWhileStatement: typeof isWhileStatement;
+declare namespace index {
+  export { index_isArrayExpression as isArrayExpression, index_isArrayPattern as isArrayPattern, index_isArrowFunctionExpression as isArrowFunctionExpression, index_isAssignmentExpression as isAssignmentExpression, index_isAssignmentProperty as isAssignmentProperty, index_isAwaitExpression as isAwaitExpression, index_isBinaryExpression as isBinaryExpression, index_isBlockStatement as isBlockStatement, index_isBreakStatement as isBreakStatement, index_isCallExpression as isCallExpression, index_isCatchClause as isCatchClause, index_isConditionalExpression as isConditionalExpression, index_isContinueStatement as isContinueStatement, index_isDirective as isDirective, index_isDoWhileStatement as isDoWhileStatement, index_isEmptyStatement as isEmptyStatement, index_isExpressionStatement as isExpressionStatement, index_isForInStatement as isForInStatement, index_isForOfStatement as isForOfStatement, index_isForStatement as isForStatement, index_isFunctionDeclaration as isFunctionDeclaration, index_isFunctionExpression as isFunctionExpression, index_isIdentifier as isIdentifier, index_isIfStatement as isIfStatement, index_isImportDeclaration as isImportDeclaration, index_isImportDefaultSpecifier as isImportDefaultSpecifier, index_isImportNamespaceSpecifier as isImportNamespaceSpecifier, index_isImportSpecifier as isImportSpecifier, index_isJsonExpression as isJsonExpression, index_isLiteral as isLiteral, index_isLogicalExpression as isLogicalExpression, index_isMemberExpression as isMemberExpression, index_isModuleDeclaration as isModuleDeclaration, index_isNewExpression as isNewExpression, index_isNode as isNode, index_isObjectExpression as isObjectExpression, index_isObjectPattern as isObjectPattern, index_isProgram as isProgram, index_isProperty as isProperty, index_isReturnStatement as isReturnStatement, index_isSwitchCase as isSwitchCase, index_isSwitchStatement as isSwitchStatement, index_isTemplateElement as isTemplateElement, index_isTemplateLiteral as isTemplateLiteral, index_isThrowStatement as isThrowStatement, index_isTryStatement as isTryStatement, index_isUnaryExpression as isUnaryExpression, index_isUpdateExpression as isUpdateExpression, index_isVariableDeclaration as isVariableDeclaration, index_isVariableDeclarator as isVariableDeclarator, index_isWhileStatement as isWhileStatement };
+}
+
+type VisitorFunction = (node: BaseNode & {
+    [key: string]: any;
+}, // <- FLEXÍVEL AQUI!
+parent: BaseNode | null) => void | false | "break";
+type WalkVisitors = {
+    [key: string]: VisitorFunction;
+    "*": VisitorFunction;
+};
+declare function walk(root: BaseNode, visitors: Partial<WalkVisitors>): void;
+
+/**
+ * Visita cada filho direto de `node`, na ordem da gramática. O callback recebe o
+ * filho, a `key` do campo onde ele mora e o `index` (quando o campo é um array,
+ * senão `null`). Não desce recursivamente — é um passo só (use `walk` p/ DFS).
+ */
+declare function forEachChild(node: BaseNode, visit: (child: BaseNode, key: string, index: number | null) => void): void;
+/** Os filhos diretos de `node`, na ordem da gramática. */
+declare function childrenOf(node: BaseNode): BaseNode[];
+
+/** Um nível de escopo léxico encadeado ao pai. */
+interface Scope<T> {
+    readonly vars: Readonly<Record<string, T>>;
+    readonly parent: Scope<T> | null;
+}
+/** Cria um escopo raiz (sem pai). */
+declare const rootScope: <T>(vars?: Record<string, T>) => Scope<T>;
+/** Estende `parent` com novos bindings, criando um escopo filho (sem mutar o pai). */
+declare const childScope: <T>(parent: Scope<T>, vars: Record<string, T>) => Scope<T>;
+/** Resolve `name` subindo a cadeia léxica. `undefined` se não existir. */
+declare function lookup<T>(scope: Scope<T>, name: string): T | undefined;
+/**
+ * Todos os nomes visíveis a partir de `scope`, com shadowing — o binding mais
+ * interno vence (alimenta autocomplete e checagens de visibilidade).
+ */
+declare function visibleNames<T>(scope: Scope<T>): Map<string, T>;
+
+declare const Mock: any;
+declare const isObject: (x: unknown) => x is Record<string, unknown>;
+declare function find<T = BaseNode>(node: any, match: (n: any) => boolean): T | undefined;
+declare function mutate<T = any>(node: T, match: (value: any) => boolean, modifier: (value: any) => any): T;
+declare function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+
+export { AST_MARKER, type ArrayExpression, type ArrayPattern, type ArrowFunctionExpression, type AssignmentExpression, type AssignmentOperator, type AssignmentPattern, type AssignmentProperty, type AwaitExpression, type BaseCallExpression, type BaseDeclaration, type BaseExpression, type BaseForXStatement, type BaseFunction, type BaseModuleDeclaration, type BaseModuleSpecifier, type BaseNode, type BaseNodeWithoutComments, type BasePattern, type BaseStatement, type BigIntLiteral, type BinaryExpression, type BinaryOperator, BinaryPrecedence, type BlockStatement, type BreakStatement, type CallExpression, type CatchClause, type ChainElement, type ChainExpression, type Comment, type ConditionalExpression, type ContinueStatement, type CoreErrorCode, type DebuggerStatement, type Declaration, type Directive, type DoWhileStatement, type EmptyStatement, type Expression, type ExpressionStatement, type ForInStatement, type ForOfStatement, type ForStatement, type Function, type FunctionDeclaration, type FunctionExpression, type Identifier, type IfStatement, type ImportDeclaration, type ImportDefaultSpecifier, type ImportExpression, type ImportNamespaceSpecifier, type ImportSpecifier, type JsonExpression, type LabeledStatement, type Literal, type LogicalExpression, type LogicalOperator, type MaybeNamedFunctionDeclaration, type MemberExpression, type MetaProperty, type MethodDefinition, Mock, type ModuleDeclaration, type ModuleSpecifier, type NewExpression, type Node, type NodeMap, type ObjectExpression, type ObjectPattern, type Pattern, type Position, Precedence, type Program, type Property, type PropertyDefinition, type RegExpLiteral, type RestElement, type ReturnStatement, type Scope, type SequenceExpression, type SimpleArrayExpression, type SimpleArrayPattern, type SimpleArrowFunctionExpression, type SimpleAssignmentExpression, type SimpleAssignmentPattern, type SimpleAssignmentProperty, type SimpleAwaitExpression, type SimpleBaseCallExpression, type SimpleBaseDeclaration, type SimpleBaseExpression, type SimpleBaseForXStatement, type SimpleBaseFunction, type SimpleBaseNode, type SimpleBaseNodeWithoutComments, type SimpleBasePattern, type SimpleBaseStatement, type SimpleBigIntLiteral, type SimpleBinaryExpression, type SimpleBlockStatement, type SimpleBreakStatement, type SimpleCallExpression, type SimpleCatchClause, type SimpleChainExpression, type SimpleComment, type SimpleConditionalExpression, type SimpleContinueStatement, type SimpleDoWhileStatement, type SimpleEmptyStatement, type SimpleExpressionStatement, type SimpleForInStatement, type SimpleForOfStatement, type SimpleForStatement, type SimpleFunctionDeclaration, type SimpleFunctionExpression, type SimpleIdentifier, type SimpleIfStatement, type SimpleJsonExpression, type SimpleLabeledStatement, type SimpleLiteral, type SimpleLogicalExpression, type SimpleMemberExpression, type SimpleMethodDefinition, type SimpleNewExpression, type SimpleNode, type SimpleObjectExpression, type SimpleObjectPattern, type SimplePosition, type SimpleProgram, type SimpleProperty, type SimplePropertyDefinition, type SimpleRegExpLiteral, type SimpleRestElement, type SimpleReturnStatement, type SimpleSequenceExpression, type SimpleSimpleCallExpression, type SimpleSimpleLiteral, type SimpleSourceLocation, type SimpleSpreadElement, type SimpleSwitchCase, type SimpleSwitchStatement, type SimpleTemplateElement, type SimpleTemplateLiteral, type SimpleThisExpression, type SimpleThrowStatement, type SimpleTryStatement, type SimpleUnaryExpression, type SimpleUpdateExpression, type SimpleVariableDeclaration, type SimpleVariableDeclarator, type SimpleWhileStatement, type SourceLocation, type SpreadElement, type Statement, type SwitchCase, type SwitchStatement, type TSLite, TSLiteError, type TSLiteMarker, type TaggedTemplateExpression, type TemplateElement, type TemplateLiteral, type ThisExpression, type ThrowStatement, type TryStatement, type UnaryExpression, type UnaryOperator, type UpdateExpression, type UpdateOperator, VALID_AST_ENTRY_TYPES, VALID_OBJECT_KEY, type ValidAstEntryType, type VariableDeclaration, type VariableDeclarator, VisitorKeys, type WhileStatement, ast, index$1 as builders, childScope, childrenOf, find, forEachChild, fromAstMarker, generateBuilders, index as guards, invalidAstEntryError, isObject, isValidAstEntryType, json, jsonExpression, lookup, mutate, pick, rootScope, types, visibleNames, walk };