rawsql-ts 0.1.0-beta.11 → 0.1.0-beta.12

package/dist/esm/types/transformers/CTECollector.d.ts

@@ -0,0 +1,81 @@
+import { CommonTable } from "../models/Clause";
+import { SelectQuery } from "../models/SelectQuery";
+import { SqlComponent, SqlComponentVisitor } from "../models/SqlComponent";
+/**
+ * A visitor that collects all CommonTable instances from a SQL query structure.
+ * This includes tables from:
+ * - WITH clauses
+ * - Subqueries
+ * - Inline queries
+ * - UNION queries
+ * - Value components that may contain queries
+ */
+export declare class CTECollector implements SqlComponentVisitor<void> {
+    private handlers;
+    private commonTables;
+    private visitedNodes;
+    private isRootVisit;
+    constructor();
+    /**
+     * Get all collected CommonTables
+     */
+    getCommonTables(): CommonTable[];
+    /**
+     * Reset the collection of CommonTables
+     */
+    private reset;
+    collect(query: SelectQuery): CommonTable[];
+    /**
+     * Main entry point for the visitor pattern.
+     * Implements the shallow visit pattern to distinguish between root and recursive visits.
+     */
+    visit(arg: SqlComponent): void;
+    /**
+     * Internal visit method used for all nodes.
+     * This separates the visit flag management from the actual node visitation logic.
+     */
+    private visitNode;
+    private visitSimpleSelectQuery;
+    private visitBinarySelectQuery;
+    private visitValuesQuery;
+    private visitWithClause;
+    private visitCommonTable;
+    private visitSelectClause;
+    private visitSelectItem;
+    private visitFromClause;
+    private visitSourceExpression;
+    private visitTableSource;
+    private visitParenSource;
+    private visitSubQuerySource;
+    private visitInlineQuery;
+    private visitJoinClause;
+    private visitJoinOnClause;
+    private visitJoinUsingClause;
+    private visitWhereClause;
+    private visitGroupByClause;
+    private visitHavingClause;
+    private visitOrderByClause;
+    private visitWindowFrameClause;
+    private visitLimitClause;
+    private visitForClause;
+    private visitOrderByItem;
+    private visitParenExpression;
+    private visitBinaryExpression;
+    private visitUnaryExpression;
+    private visitCaseExpression;
+    private visitSwitchCaseArgument;
+    private visitCaseKeyValuePair;
+    private visitBetweenExpression;
+    private visitFunctionCall;
+    private visitArrayExpression;
+    private visitTupleExpression;
+    private visitCastExpression;
+    private visitTypeValue;
+    private visitWindowFrameExpression;
+    private visitWindowFrameSpec;
+    private visitIdentifierString;
+    private visitRawString;
+    private visitColumnReference;
+    private visitParameterExpression;
+    private visitLiteralValue;
+}

package/dist/esm/types/transformers/CTEDisabler.d.ts

@@ -0,0 +1,77 @@
+import { ForClause, FromClause, GroupByClause, HavingClause, JoinClause, JoinOnClause, JoinUsingClause, LimitClause, OrderByClause, OrderByItem, ParenSource, SelectClause, SelectItem, SourceExpression, SubQuerySource, TableSource, WhereClause, WindowFrameClause } from "../models/Clause";
+import { BinarySelectQuery, SimpleSelectQuery, SelectQuery, ValuesQuery } from "../models/SelectQuery";
+import { SqlComponent, SqlComponentVisitor } from "../models/SqlComponent";
+import { ArrayExpression, BetweenExpression, BinaryExpression, CaseExpression, CaseKeyValuePair, CastExpression, ColumnReference, FunctionCall, InlineQuery, ParenExpression, ParameterExpression, SwitchCaseArgument, TupleExpression, UnaryExpression, ValueComponent, WindowFrameExpression, IdentifierString, RawString, WindowFrameSpec, TypeValue } from "../models/ValueComponent";
+/**
+ * A visitor that disables all WITH clauses in a SQL query structure.
+ * This processes and removes WITH clauses from:
+ * - Simple SELECT queries
+ * - Binary queries (UNION, EXCEPT, etc.)
+ * - Subqueries
+ * - Inline queries
+ *
+ * It maintains the CTE queries themselves but restructures the query to not use
+ * the WITH clause syntactical construct.
+ */
+export declare class CTEDisabler implements SqlComponentVisitor<SqlComponent> {
+    private handlers;
+    private visitedNodes;
+    private isRootVisit;
+    constructor();
+    /**
+     * Reset the visited nodes tracking
+     */
+    private reset;
+    execute(arg: SqlComponent): SelectQuery;
+    /**
+     * Main entry point for the visitor pattern.
+     * Implements the shallow visit pattern to distinguish between root and recursive visits.
+     */
+    visit(arg: SqlComponent): SqlComponent;
+    /**
+     * Internal visit method used for all nodes.
+     * This separates the visit flag management from the actual node visitation logic.
+     */
+    private visitNode;
+    visitSimpleSelectQuery(arg: SimpleSelectQuery): SqlComponent;
+    visitBinarySelectQuery(query: BinarySelectQuery): SqlComponent;
+    visitValuesQuery(query: ValuesQuery): SqlComponent;
+    visitSelectClause(clause: SelectClause): SqlComponent;
+    visitFromClause(clause: FromClause): SqlComponent;
+    visitSubQuerySource(subQuery: SubQuerySource): SqlComponent;
+    visitInlineQuery(inlineQuery: InlineQuery): SqlComponent;
+    visitJoinClause(joinClause: JoinClause): SqlComponent;
+    visitJoinOnClause(joinOn: JoinOnClause): SqlComponent;
+    visitJoinUsingClause(joinUsing: JoinUsingClause): SqlComponent;
+    visitWhereClause(whereClause: WhereClause): SqlComponent;
+    visitGroupByClause(clause: GroupByClause): SqlComponent;
+    visitHavingClause(clause: HavingClause): SqlComponent;
+    visitOrderByClause(clause: OrderByClause): SqlComponent;
+    visitWindowFrameClause(clause: WindowFrameClause): SqlComponent;
+    visitLimitClause(clause: LimitClause): SqlComponent;
+    visitForClause(clause: ForClause): SqlComponent;
+    visitParenExpression(expr: ParenExpression): SqlComponent;
+    visitBinaryExpression(expr: BinaryExpression): SqlComponent;
+    visitUnaryExpression(expr: UnaryExpression): SqlComponent;
+    visitCaseExpression(expr: CaseExpression): SqlComponent;
+    visitSwitchCaseArgument(switchCase: SwitchCaseArgument): SqlComponent;
+    visitCaseKeyValuePair(pair: CaseKeyValuePair): SqlComponent;
+    visitBetweenExpression(expr: BetweenExpression): SqlComponent;
+    visitFunctionCall(func: FunctionCall): SqlComponent;
+    visitArrayExpression(expr: ArrayExpression): SqlComponent;
+    visitTupleExpression(expr: TupleExpression): SqlComponent;
+    visitCastExpression(expr: CastExpression): SqlComponent;
+    visitTypeValue(typeValue: TypeValue): SqlComponent;
+    visitSelectItem(item: SelectItem): SqlComponent;
+    visitIdentifierString(ident: IdentifierString): SqlComponent;
+    visitRawString(raw: RawString): SqlComponent;
+    visitColumnReference(column: ColumnReference): SqlComponent;
+    visitSourceExpression(source: SourceExpression): SqlComponent;
+    visitTableSource(source: TableSource): SqlComponent;
+    visitParenSource(source: ParenSource): SqlComponent;
+    visitParameterExpression(param: ParameterExpression): SqlComponent;
+    visitWindowFrameExpression(expr: WindowFrameExpression): SqlComponent;
+    visitWindowFrameSpec(spec: WindowFrameSpec): SqlComponent;
+    visitLiteralValue(value: ValueComponent): SqlComponent;
+    visitOrderByItem(item: OrderByItem): SqlComponent;
+}

package/dist/esm/types/transformers/CTEInjector.d.ts

@@ -0,0 +1,40 @@
+import { CommonTable } from "../models/Clause";
+import { SelectQuery } from "../models/SelectQuery";
+/**
+ * CTEInjector accepts a SelectQuery object and an array of CommonTables,
+ * and inserts Common Table Expressions into the query.
+ * For BinarySelectQuery, CTEs are inserted into the left query.
+ *
+ * Uses CTENameConflictResolver to resolve naming conflicts between CTEs.
+ */
+export declare class CTEInjector {
+    private nameConflictResolver;
+    private cteCollector;
+    constructor();
+    /**
+     * Inserts Common Table Expressions into a SelectQuery object.
+     *
+     * @param query The query to inject CTEs into
+     * @param commonTables Array of CommonTables to be inserted
+     * @returns A new query with the injected CTEs
+     */
+    inject(query: SelectQuery, commonTables: CommonTable[]): SelectQuery;
+    /**
+     * Inserts Common Table Expressions into a SimpleSelectQuery.
+     *
+     * @param query The SimpleSelectQuery to inject CTEs into
+     * @param commonTables Array of CommonTables to be inserted
+     * @param needRecursive Boolean indicating if recursive WITH clause is needed
+     * @returns A new SimpleSelectQuery with the injected CTEs
+     */
+    private injectIntoSimpleQuery;
+    /**
+     * Inserts Common Table Expressions into the left query of a BinarySelectQuery.
+     *
+     * @param query The BinarySelectQuery to inject CTEs into
+     * @param commonTables Array of CommonTables to be inserted
+     * @param needRecursive Boolean indicating if recursive WITH clause is needed
+     * @returns A new BinarySelectQuery with the injected CTEs
+     */
+    private injectIntoBinaryQuery;
+}

package/dist/esm/types/transformers/CTENormalizer.d.ts

@@ -0,0 +1,25 @@
+import { SelectQuery } from "../models/SelectQuery";
+/**
+ * CTENormalizer is responsible for normalizing Common Table Expressions (CTEs) within SQL queries.
+ * It collects all CTEs from various parts of the query and consolidates them into a single WITH clause
+ * at the root level of the query.
+ *
+ * This implementation uses:
+ * 1. CommonTableCollector - to gather all CTEs from the query structure
+ * 2. WithClauseDisabler - to remove all original WITH clauses from the query
+ * 3. CTENameConflictResolver - to resolve name conflicts among CTEs and sort them properly
+ */
+export declare class CTENormalizer {
+    /**
+     * Private constructor to prevent instantiation of this utility class.
+     */
+    private constructor();
+    /**
+     * Normalizes a SQL query by consolidating all CTEs into a single WITH clause
+     * at the root level of the query.
+     *
+     * @param query The query to normalize
+     * @returns A new normalized query with all CTEs at the root level
+     */
+    static normalize(query: SelectQuery): SelectQuery;
+}

package/dist/esm/types/transformers/Formatter.d.ts

@@ -0,0 +1,82 @@
+import { SqlComponent, SqlComponentVisitor } from "../models/SqlComponent";
+interface FormatterConfig {
+    identifierEscape: {
+        start: string;
+        end: string;
+    };
+    parameterSymbol: string;
+}
+export declare class Formatter implements SqlComponentVisitor<string> {
+    private handlers;
+    private config;
+    constructor();
+    /**
+     * Formats the given SQL AST node into a SQL string.
+     * This is the recommended public API for users.
+     * @param arg The root SQL AST node to format.
+     * @param config (Optional) Formatter configuration.
+     * @returns The formatted SQL string.
+     */
+    format(arg: SqlComponent, config?: FormatterConfig | null): string;
+    /**
+     * Visitor entry point for SQL AST nodes.
+     * Note: This method is public only for interface compatibility.
+     *       Users should call the format() method instead of visit() directly.
+     *       (If you call visit() directly, you are basically breaking the abstraction, so don't do it!)
+     * @param arg The SQL AST node to visit.
+     * @returns The formatted SQL string for the node.
+     */
+    visit(arg: SqlComponent): string;
+    private visitBinarySelectQuery;
+    private visitWindowFrameBoundaryValue;
+    private visitWindowFrameBoundStatic;
+    private visitWindowFrameExpression;
+    private visitWindowFrameSpec;
+    private visitJoinUsingClause;
+    private visitJoinOnClause;
+    private visitTypeValue;
+    private visitStringSpecifierExpression;
+    private visitWithClause;
+    private visitCommonTable;
+    private visitDistinctOn;
+    private visitDistinct;
+    private visitHavingClause;
+    private visitGroupByClause;
+    private visitFromClause;
+    private visitJoinClause;
+    private visitSourceAliasExpression;
+    private visitSourceExpression;
+    private visitSubQuerySource;
+    private visitFunctionSource;
+    private visitTableSource;
+    private visitValueList;
+    private visitSwitchCaseArgument;
+    private visitColumnReference;
+    private visitFunctionCall;
+    private visitUnaryExpression;
+    private visitBinaryExpression;
+    private visitLiteralExpression;
+    private visitParameterExpression;
+    private visitSelectExpression;
+    private visitSelectClause;
+    private visitSelectQuery;
+    private visitArrayExpression;
+    private visitCaseExpression;
+    private visitCastExpression;
+    private visitBracketExpression;
+    private visitBetweenExpression;
+    private visitPartitionByClause;
+    private visitOrderByClause;
+    private visitOrderByItem;
+    private visitWindowFrameClause;
+    private visitLimitClause;
+    private visitFetchSpecification;
+    private visitForClause;
+    private visitWhereClause;
+    private visitInlineQuery;
+    private visitRawString;
+    private visitIdentifierString;
+    private visitValuesQuery;
+    private visitTupleExpression;
+}
+export {};

package/dist/esm/types/transformers/QueryConverter.d.ts

@@ -0,0 +1,41 @@
+import { SelectQuery, SimpleSelectQuery } from "../models/SelectQuery";
+/**
+ * Converts various SELECT query types to a standard SimpleSelectQuery format.
+ * - SimpleSelectQuery is returned as-is
+ * - BinarySelectQuery (UNION, etc.) is wrapped in a subquery: SELECT * FROM (original) AS bq
+ * - ValuesQuery is wrapped with sequentially numbered columns: SELECT * FROM (original) AS vq(column1, column2, ...)
+ */
+export declare class QueryConverter {
+    /**
+     * Private constructor to prevent instantiation of this utility class.
+     */
+    private constructor();
+    /**
+     * Converts a SELECT query to a standard SimpleSelectQuery form.
+     *
+     * @param query The query to convert
+     * @returns A SimpleSelectQuery
+     */
+    static toSimple(query: SelectQuery): SimpleSelectQuery;
+    /**
+     * Converts a BinarySelectQuery (UNION, EXCEPT, etc.) to a SimpleSelectQuery
+     * by wrapping it in SELECT * FROM (original) AS bq
+     *
+     * @param query The binary query to convert
+     * @returns A SimpleSelectQuery
+     */
+    private static toSimpleBinaryQuery;
+    /**
+     * Converts a ValuesQuery to a SimpleSelectQuery with sequentially numbered columns
+     *
+     * @param query The VALUES query to convert
+     * @returns A SimpleSelectQuery
+     */
+    private static toSimpleValuesQuery;
+    /**
+     * Creates a SELECT clause with a single * (all columns) item
+     *
+     * @returns A SELECT clause with *
+     */
+    private static createSelectAllClause;
+}

package/dist/esm/types/transformers/SelectValueCollector.d.ts

@@ -0,0 +1,60 @@
+import { CommonTable } from "../models/Clause";
+import { SqlComponent, SqlComponentVisitor } from "../models/SqlComponent";
+import { ValueComponent } from "../models/ValueComponent";
+import { TableColumnResolver } from "./TableColumnResolver";
+/**
+ * A visitor that collects all SelectItem instances from a SQL query structure.
+ * This visitor scans through select clauses and collects all the SelectItem objects.
+ * It can also resolve wildcard selectors (table.* or *) using a provided table column resolver.
+ */
+export declare class SelectValueCollector implements SqlComponentVisitor<void> {
+    private handlers;
+    private selectValues;
+    private visitedNodes;
+    private isRootVisit;
+    private tableColumnResolver?;
+    private commonTableCollector;
+    private commonTables;
+    initialCommonTables: CommonTable[] | null;
+    constructor(tableColumnResolver?: TableColumnResolver, initialCommonTables?: CommonTable[] | null);
+    /**
+     * Get all collected SelectItems as an array of objects with name and value properties
+     * @returns An array of objects with name (string) and value (ValueComponent) properties
+     */
+    getValues(): {
+        name: string;
+        value: ValueComponent;
+    }[];
+    /**
+     * Reset the collection of SelectItems
+     */
+    private reset;
+    collect(arg: SqlComponent): {
+        name: string;
+        value: ValueComponent;
+    }[];
+    /**
+     * Main entry point for the visitor pattern.
+     * Implements the shallow visit pattern to distinguish between root and recursive visits.
+     */
+    visit(arg: SqlComponent): void;
+    /**
+     * Internal visit method used for all nodes.
+     * This separates the visit flag management from the actual node visitation logic.
+     */
+    private visitNode;
+    /**
+     * Process a SimpleSelectQuery to collect data and store the current context
+     */
+    private visitSimpleSelectQuery;
+    private processFromClause;
+    private processJoinClause;
+    private processSourceExpression;
+    private visitSelectClause;
+    private processSelectItem;
+    private processValueComponent;
+    private visitSourceExpression;
+    private visitFromClause;
+    private addSelectValueAsUnique;
+}
+export { TableColumnResolver };

package/dist/esm/types/transformers/SelectableColumnCollector.d.ts

@@ -0,0 +1,70 @@
+import { SqlComponent, SqlComponentVisitor } from "../models/SqlComponent";
+import { ValueComponent } from "../models/ValueComponent";
+import { TableColumnResolver } from "./SelectValueCollector";
+/**
+ * A visitor that collects all ColumnReference instances from a SQL query structure.
+ * This visitor scans through all clauses and collects all unique ColumnReference objects.
+ * It does not scan Common Table Expressions (CTEs) or subqueries.
+ *
+ * Important: Only collects column references to tables defined in the root FROM/JOIN clauses,
+ * as these are the only columns that can be directly referenced in the query.
+ */
+export declare class SelectableColumnCollector implements SqlComponentVisitor<void> {
+    private handlers;
+    private selectValues;
+    private visitedNodes;
+    private formatter;
+    private isRootVisit;
+    private tableColumnResolver?;
+    private commonTableCollector;
+    private selectValueCollector;
+    private commonTables;
+    constructor(tableColumnResolver?: TableColumnResolver);
+    getValues(): {
+        name: string;
+        value: ValueComponent;
+    }[];
+    collect(arg: SqlComponent): {
+        name: string;
+        value: ValueComponent;
+    }[];
+    /**
+     * Reset the collection of ColumnReferences
+     */
+    private reset;
+    private addSelectValueAsUnique;
+    /**
+     * Main entry point for the visitor pattern.
+     * Implements the shallow visit pattern to distinguish between root and recursive visits.
+     */
+    visit(arg: SqlComponent): void;
+    /**
+     * Internal visit method used for all nodes.
+     * This separates the visit flag management from the actual node visitation logic.
+     */
+    private visitNode;
+    /**
+      * Process a SimpleSelectQuery to collect ColumnReferences from all its clauses
+      */
+    private visitSimpleSelectQuery;
+    private visitSelectClause;
+    private visitFromClause;
+    private visitWhereClause;
+    private visitGroupByClause;
+    private visitHavingClause;
+    private visitOrderByClause;
+    private visitWindowFrameClause;
+    private visitLimitClause;
+    private visitJoinOnClause;
+    private visitJoinUsingClause;
+    private visitColumnReference;
+    private visitBinaryExpression;
+    private visitUnaryExpression;
+    private visitFunctionCall;
+    private visitParenExpression;
+    private visitCaseExpression;
+    private visitCastExpression;
+    private visitBetweenExpression;
+    private visitArrayExpression;
+    private visitValueList;
+}

package/dist/esm/types/transformers/TableColumnResolver.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Type definition for a function that resolves column names from a table name.
+ *
+ * This is used to provide table structure information (column names) for physical tables
+ * when expanding wildcard selectors (e.g., table.*) in SQL query analysis.
+ *
+ * @param tableName The name of the table to resolve columns for.
+ * @returns An array of column names (strings) for the specified table.
+ */
+export type TableColumnResolver = (tableName: string) => string[];

package/dist/esm/types/transformers/TableSourceCollector.d.ts

@@ -0,0 +1,92 @@
+import { TableSource } from "../models/Clause";
+import { SqlComponent, SqlComponentVisitor } from "../models/SqlComponent";
+/**
+ * A visitor that collects all table source names from a SQL query structure.
+ *
+ * When selectableOnly is true (default behavior):
+ * - Includes only table sources from FROM and JOIN clauses
+ * - Excludes inline queries, subqueries, and CTEs
+ *
+ * When selectableOnly is false:
+ * - Scans all parts of the query including WITH clauses, subqueries, etc.
+ * - Collects all table sources from the entire query
+ * - Excludes tables that are managed by CTEs
+ *
+ * For UNION-like queries, it scans both the left and right parts.
+ */
+export declare class TableSourceCollector implements SqlComponentVisitor<void> {
+    private handlers;
+    private tableSources;
+    private visitedNodes;
+    private tableNameMap;
+    private selectableOnly;
+    private cteNames;
+    private isRootVisit;
+    constructor(selectableOnly?: boolean);
+    /**
+     * Gets all collected table sources
+     */
+    getTableSources(): TableSource[];
+    /**
+     * Reset the collection of table sources
+     */
+    private reset;
+    /**
+     * Gets a unique identifier for a table source
+     */
+    private getTableIdentifier;
+    collect(query: SqlComponent): TableSource[];
+    /**
+     * Main entry point for the visitor pattern.
+     * Implements the shallow visit pattern to distinguish between root and recursive visits.
+     */
+    visit(arg: SqlComponent): void;
+    /**
+     * Internal visit method used for all nodes.
+     * This separates the visit flag management from the actual node visitation logic.
+     */
+    private visitNode;
+    /**
+     * Collects all CTE names to exclude them from real table sources
+     */
+    private collectCTEs;
+    private visitSimpleSelectQuery;
+    private visitBinarySelectQuery;
+    private visitValuesQuery;
+    private visitWithClause;
+    private visitCommonTable;
+    private visitFromClause;
+    private visitSourceExpression;
+    private visitTableSource;
+    /**
+     * Checks if a table name is a CTE name
+     */
+    private isCTETable;
+    private visitParenSource;
+    private visitSubQuerySource;
+    private visitInlineQuery;
+    private visitJoinClause;
+    private visitJoinOnClause;
+    private visitJoinUsingClause;
+    private visitWhereClause;
+    private visitGroupByClause;
+    private visitHavingClause;
+    private visitOrderByClause;
+    private visitWindowFrameClause;
+    private visitLimitClause;
+    private visitForClause;
+    private visitOrderByItem;
+    private visitSelectClause;
+    private visitSelectItem;
+    private visitParenExpression;
+    private visitBinaryExpression;
+    private visitUnaryExpression;
+    private visitCaseExpression;
+    private visitSwitchCaseArgument;
+    private visitCaseKeyValuePair;
+    private visitBetweenExpression;
+    private visitFunctionCall;
+    private visitArrayExpression;
+    private visitTupleExpression;
+    private visitCastExpression;
+}

package/dist/esm/types/transformers/UpstreamSelectQueryFinder.d.ts

@@ -0,0 +1,27 @@
+import { SelectQuery } from "../models/SelectQuery";
+/**
+ * UpstreamSelectQueryFinder searches upstream queries for the specified columns.
+ * If a query (including its upstream CTEs or subqueries) contains all columns,
+ * it returns the highest such SelectQuery. Otherwise, it searches downstream.
+ * For UNION queries, it checks each branch independently.
+ */
+export declare class UpstreamSelectQueryFinder {
+    private tableColumnResolver?;
+    private columnCollector;
+    constructor(tableColumnResolver?: (tableName: string) => string[]);
+    /**
+     * Finds the highest SelectQuery containing all specified columns.
+     * @param query The root SelectQuery to search.
+     * @param columnNames Array of column names to check for.
+     * @returns An array of SelectQuery objects, or an empty array if not found.
+     */
+    find(query: SelectQuery, columnNames: string[]): SelectQuery[];
+    private handleTableSource;
+    private handleSubQuerySource;
+    /**
+     * Processes all source branches in a FROM clause and checks if all upstream queries contain the specified columns.
+     * Returns a flat array of SelectQuery if all branches are valid, otherwise null.
+     */
+    private processFromClauseBranches;
+    private findUpstream;
+}

package/dist/esm/types/utils/charLookupTable.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Fast character classification utilities for SQL tokenization
+ */
+export declare class CharLookupTable {
+    static isWhitespace(char: string): boolean;
+    static isDigit(char: string): boolean;
+    static isHexChar(char: string): boolean;
+    static isOperatorSymbol(char: string): boolean;
+    static isDelimiter(char: string): boolean;
+    static isNamedParameterPrefix(char: string): boolean;
+}

package/dist/esm/types/utils/stringUtils.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Utilities for string operations during tokenization
+ */
+export declare class StringUtils {
+    /**
+     * Creates a visual representation of an error position in text
+     * @param input The input text
+     * @param errPosition The error position
+     * @returns A string with a caret pointing to the error position
+     */
+    static getDebugPositionInfo(input: string, errPosition: number): string;
+    /**
+     * Skip white space characters.
+     */
+    private static skipWhiteSpace;
+    /**
+     * Skip line comment.
+     */
+    private static readLineComment;
+    /**
+     * Skip block comment.
+     */
+    private static readBlockComment;
+    /**
+     * Skip white space characters and SQL comments.
+     * @returns Object containing the new position and an array of skipped comments
+     */
+    static readWhiteSpaceAndComment(input: string, position: number): {
+        position: number;
+        lines: string[];
+    };
+    /**
+     * Read a regular identifier.
+     */
+    static readRegularIdentifier(input: string, position: number): {
+        identifier: string;
+        newPosition: number;
+    };
+    static tryReadRegularIdentifier(input: string, position: number): {
+        identifier: string;
+        newPosition: number;
+    } | null;
+}