Continue mangle optimization

Author: tolyo

@types/core/parse/ast/ast.d.ts

@@ -21,135 +21,135 @@ export class AST {
    * @param {string} text - The input text to parse.
    * @returns {ASTNode} The root node of the AST.
    */
-  ast(text: string): ASTNode;
+  _ast(text: string): ASTNode;
   text: string;
   tokens: import("../lexer/token.js").Token[];
   /**
    * Parses a program.
    * @returns {ASTNode} The program node.
    */
-  program(): ASTNode;
+  _program(): ASTNode;
   /**
    * Parses an expression statement.
    * @returns {ASTNode} The expression statement node.
    */
-  expressionStatement(): ASTNode;
+  _expressionStatement(): ASTNode;
   /**
    * Parses a filter chain.
    * @returns {ASTNode} The filter chain node.
    */
-  filterChain(): ASTNode;
+  _filterChain(): ASTNode;
   /**
    * Parses an assignment expression.
    * @returns {ASTNode} The assignment expression node.
    */
-  assignment(): ASTNode;
+  _assignment(): ASTNode;
   /**
    * Parses a ternary expression.
    * @returns {ASTNode} The ternary expression node.
    */
-  ternary(): ASTNode;
+  _ternary(): ASTNode;
   /**
    * Parses a logical OR expression.
    * @returns {ASTNode} The logical OR expression node.
    */
-  logicalOR(): ASTNode;
+  _logicalOR(): ASTNode;
   /**
    * Parses a logical AND expression.
    * @returns {ASTNode} The logical AND expression node.
    */
-  logicalAND(): ASTNode;
+  _logicalAND(): ASTNode;
   /**
    * Parses an equality expression.
    * @returns {ASTNode} The equality expression node.
    */
-  equality(): ASTNode;
+  _equality(): ASTNode;
   /**
    * Parses a relational expression.
    * @returns {ASTNode} The relational expression node.
    */
-  relational(): ASTNode;
+  _relational(): ASTNode;
   /**
    * Parses an additive expression.
    * @returns {ASTNode} The additive expression node.
    */
-  additive(): ASTNode;
+  _additive(): ASTNode;
   /**
    * Parses a multiplicative expression.
    * @returns {ASTNode} The multiplicative expression node.
    */
-  multiplicative(): ASTNode;
+  _multiplicative(): ASTNode;
   /**
    * Parses a unary expression.
    * @returns {ASTNode} The unary expression node.
    */
-  unary(): ASTNode;
+  _unary(): ASTNode;
   /**
    * Parses a primary expression.
    * @returns {ASTNode} The primary expression node.
    */
-  primary(): ASTNode;
+  _primary(): ASTNode;
   /**
    * Parses a filter.
    * @param {ASTNode} baseExpression - The base expression to apply the filter to.
    * @returns {ASTNode} The filter node.
    */
-  filter(baseExpression: ASTNode): ASTNode;
+  _filter(baseExpression: ASTNode): ASTNode;
   /**
    * Parses function arguments.
    * @returns {ASTNode[]} The arguments array.
    */
-  parseArguments(): ASTNode[];
+  _parseArguments(): ASTNode[];
   /**
    * Parses an identifier.
    * @returns {ASTNode} The identifier node.
    */
-  identifier(): ASTNode;
+  _identifier(): ASTNode;
   /**
    * Parses a constant.
    * @returns {ASTNode} The constant node.
    */
-  constant(): ASTNode;
+  _constant(): ASTNode;
   /**
    * Parses an array declaration.
    * @returns {ASTNode} The array declaration node.
    */
-  arrayDeclaration(): ASTNode;
+  _arrayDeclaration(): ASTNode;
   /**
    * Parses an object.
    * @returns {ASTNode} The object node.
    */
-  object(): ASTNode;
+  _object(): ASTNode;
   /**
    * Throws a syntax error.
    * @param {string} msg - The error message.
    * @param {import("../lexer/lexer.js").Token} [token] - The token that caused the error.
    */
-  throwError(msg: string, token?: import("../lexer/lexer.js").Token): void;
+  _throwError(msg: string, token?: import("../lexer/lexer.js").Token): void;
   /**
    * Consumes a token if it matches the expected type.
    * @param {string} [e1] - The expected token type.
    * @returns {import("../lexer/lexer.js").Token} The consumed token.
    */
-  consume(e1?: string): import("../lexer/lexer.js").Token;
+  _consume(e1?: string): import("../lexer/lexer.js").Token;
   /**
    * Returns the next token without consuming it.
    * @returns {import("../lexer/lexer.js").Token} The next token.
    */
-  peekToken(): import("../lexer/lexer.js").Token;
+  _peekToken(): import("../lexer/lexer.js").Token;
   /**
    * Checks if the next token matches any of the expected types.
    * @param {...string} [expected] - The expected token types.
    * @returns {import('../lexer/lexer.js').Token|boolean} The next token if it matches, otherwise false.
    */
-  peek(...expected: string[]): import("../lexer/lexer.js").Token | boolean;
+  _peek(...expected: string[]): import("../lexer/lexer.js").Token | boolean;
   /**
    * Checks if the token at the specified index matches any of the expected types.
    * @param {number} i - The index to check.
    * @param {...string} [expected] - The expected token types.
    * @returns {import("../lexer/lexer.js").Token|boolean} The token at the specified index if it matches, otherwise false.
    */
-  peekAhead(
+  _peekAhead(
     i: number,
     ...expected: string[]
   ): import("../lexer/lexer.js").Token | boolean;
@@ -158,7 +158,7 @@ export class AST {
    * @param {...string} [expected] - The expected token types.
    * @returns {import("../lexer/lexer.js").Token|boolean} The consumed token if it matches, otherwise false.
    */
-  expect(...expected: string[]): import("../lexer/lexer.js").Token | boolean;
+  _expect(...expected: string[]): import("../lexer/lexer.js").Token | boolean;
 }
 export type ASTNode = import("./ast-node.ts").ASTNode;
 export type Token = import("../lexer/token.js").Token;

@types/core/parse/lexer/lexer.d.ts

@@ -20,91 +20,91 @@ export class Lexer {
    * @param {string} text Input text to lex.
    * @returns {Array<Token>} Array of tokens.
    */
-  lex(text: string): Array<Token>;
-  text: string;
-  index: number;
+  _lex(text: string): Array<Token>;
+  _text: string;
+  _index: number;
   /** @type {Array<Token>} */
-  tokens: Array<Token>;
+  _tokens: Array<Token>;
   /**
    * Checks if a character is contained in a set of characters.
    * @param {string} ch Character to check.
    * @param {string} chars Set of characters.
    * @returns {boolean} True if character is in the set, false otherwise.
    */
-  is(ch: string, chars: string): boolean;
+  _is(ch: string, chars: string): boolean;
   /**
    * Peeks at the next character in the text.
    * @param {number} [i=1] Number of characters to peek.
    * @returns {string|false} Next character or false if end of text.
    */
-  peek(i?: number): string | false;
+  _peek(i?: number): string | false;
   /**
    * Checks if a character is a number.
    * @param {string} ch Character to check.
    * @returns {boolean} True if character is a number, false otherwise.
    */
-  isNumber(ch: string): boolean;
+  _isNumber(ch: string): boolean;
   /**
    * Checks if a character is whitespace.
    * @param {string} ch Character to check.
    * @returns {boolean} True if character is whitespace, false otherwise.
    */
-  isWhitespace(ch: string): boolean;
+  _isWhitespace(ch: string): boolean;
   /**
    * Checks if a character is a valid identifier start.
    * @param {string} ch Character to check.
    * @returns {boolean} True if character is a valid identifier start, false otherwise.
    */
-  isIdentifierStart(ch: string): boolean;
+  _isIdentifierStart(ch: string): boolean;
   /**
    * Checks if a character is a valid identifier continuation.
    * @param {string} ch Character to check.
    * @returns {boolean} True if character is a valid identifier continuation, false otherwise.
    */
-  isIdentifierContinue(ch: string): boolean;
+  _isIdentifierContinue(ch: string): boolean;
   /**
    * Converts a character to its Unicode code point.
    * @param {string} ch Character to convert.
    * @returns {number} Unicode code point.
    */
-  codePointAt(ch: string): number;
+  _codePointAt(ch: string): number;
   /**
    * Peeks at the next multicharacter sequence in the text.
    * @returns {string} Next multicharacter sequence.
    */
-  peekMultichar(): string;
+  _peekMultichar(): string;
   /**
    * Checks if a character is an exponent operator.
    * @param {string} ch Character to check.
    * @returns {boolean} True if character is an exponent operator, false otherwise.
    */
-  isExpOperator(ch: string): boolean;
+  _isExpOperator(ch: string): boolean;
   /**
    * Throws a lexer error.
    * @param {string} error Error message.
    * @param {number} [start] Start index.
    * @param {number} [end] End index.
    * @throws {Error} Lexer error.
    */
-  throwError(error: string, start?: number, end?: number): void;
+  _throwError(error: string, start?: number, end?: number): void;
   /**
    * Reads and tokenizes a number from the text.
    * @return {void}
    */
-  readNumber(): void;
+  _readNumber(): void;
   /**
    * Reads and tokenizes an identifier from the text.
    */
-  readIdent(): void;
+  _readIdent(): void;
   /**
    * Reads and tokenizes a string from the text.
    * @param {string} quote Quote character used for the string.
    */
-  readString(quote: string): void;
+  _readString(quote: string): void;
   /**
    * @returns {string}
    */
-  handleUnicodeEscape(): string;
+  _handleUnicodeEscape(): string;
 }
 export type Token = import("./token.ts").Token;
 export type LexerOptions = {