@tablecraft-app/plugin-api 0.0.0-stage → 1.2.0

package/dist/sql/inspectStyle.js

@@ -0,0 +1,384 @@
+import { problem, removal } from "./inspectContext.js";
+import { referenceName } from "./resolution.js";
+import { CLAUSE_WORDS, NO_GROUP, unquote } from "./scope.js";
+const OPEN = "(";
+const CLOSE = ")";
+const COMMA = ",";
+const WHERE = "WHERE";
+const NULL = "NULL";
+const AND = "AND";
+const OR = "OR";
+const ON = "ON";
+const BETWEEN = "BETWEEN";
+const TRUE = "TRUE";
+const FALSE = "FALSE";
+const ASC = "ASC";
+const ELSE = "ELSE";
+const END = "END";
+const AS = "AS";
+const WITH = "WITH";
+const ROW = "ROW";
+const VALUES_WORDS = new Set(["VALUES", "VALUE"]);
+const RECURSIVE = "RECURSIVE";
+const CTE_MODIFIERS = new Set(["NOT", "MATERIALIZED"]);
+const ORDER_BY = "ORDER BY";
+const UNFILTERED_VERBS = new Set(["DELETE", "UPDATE"]);
+/** Clauses `WHERE` must come before, so its placeholder goes ahead of them. */
+const AFTER_WHERE = new Set(["ORDER", "LIMIT", "RETURNING"]);
+const CONDITION_CLAUSES = new Set([WHERE, ON, "HAVING"]);
+const NULL_COMPARISON_CLAUSES = new Set([...CONDITION_CLAUSES, "SELECT"]);
+const COMPARISONS = new Set(["=", "<>", "!=", "<", ">", "<=", ">="]);
+const OPERATOR_CHARACTER = /^[<>=!]$/;
+/** Join words that end an `ON` condition without being clause keywords. */
+const JOIN_WORDS = new Set(["INNER", "LEFT", "RIGHT", "FULL", "CROSS", "NATURAL", "OUTER"]);
+const NUMBER = /^[0-9]+(?:\.[0-9]*)?$/;
+const WHERE_PLACEHOLDER = "WHERE ";
+/** `INSERT INTO t (a, b) VALUES (1)`: each row against the column list (SqlInsertValues). */
+function insertValues(view, query) {
+    if (query.insert === null)
+        return [];
+    const { statement } = view;
+    const listOpen = view.indexAt(query.insert.from - 1);
+    const expected = itemCount(view, listOpen);
+    const level = statement.level(view.queries.get(query) ?? NO_GROUP);
+    const start = level.indexOf(listOpen) + 1;
+    if (start === 0 || !VALUES_WORDS.has(view.word(level[start] ?? -1) ?? ""))
+        return [];
+    const problems = [];
+    for (let at = start + 1; at < level.length; at += 1) {
+        let index = level[at] ?? -1;
+        if (view.word(index) === ROW)
+            index = level[++at] ?? -1;
+        if (!view.isSymbol(index, OPEN))
+            break;
+        const openToken = view.token(index);
+        const closeToken = view.token(statement.closeOf(index));
+        const found = itemCount(view, index);
+        if (openToken !== undefined && closeToken !== undefined && found !== expected) {
+            const noun = expected === 1 ? "value" : "values";
+            problems.push(problem("SqlInsertValues", "error", { from: openToken.from, to: closeToken.to }, `Expected ${String(expected)} ${noun}, found ${String(found)}`));
+        }
+        if (!view.isSymbol(level[at + 1] ?? -1, COMMA))
+            break;
+        at += 1;
+    }
+    return problems;
+}
+function itemCount(view, open) {
+    const inside = view.statement.level(open);
+    if (inside.length === 0)
+        return 0;
+    return inside.filter((index) => view.isSymbol(index, COMMA)).length + 1;
+}
+/** `DELETE` or `UPDATE` with no `WHERE` at the statement's own level (SqlWithoutWhere). */
+function withoutWhere(view) {
+    const verb = view.verb;
+    if (verb === null || !UNFILTERED_VERBS.has(verb) || !view.inspected)
+        return [];
+    const level = view.statement.level(NO_GROUP);
+    const verbIndex = level.find((index) => view.word(index) === verb);
+    const verbToken = verbIndex === undefined ? undefined : view.token(verbIndex);
+    if (verbIndex === undefined || verbToken === undefined)
+        return [];
+    const after = level.filter((index) => index > verbIndex);
+    if (after.some((index) => view.word(index) === WHERE))
+        return [];
+    const before = after.find((index) => AFTER_WHERE.has(view.word(index) ?? ""));
+    const beforeToken = before === undefined ? undefined : view.token(before);
+    const fix = beforeToken === undefined
+        ? {
+            title: "Add WHERE clause",
+            edits: [{ from: view.end, to: view.end, insert: ` ${WHERE_PLACEHOLDER}` }],
+            caret: view.end + WHERE_PLACEHOLDER.length + 1,
+        }
+        : {
+            title: "Add WHERE clause",
+            edits: [{ from: beforeToken.from, to: beforeToken.from, insert: `${WHERE_PLACEHOLDER} ` }],
+            caret: beforeToken.from + WHERE_PLACEHOLDER.length,
+        };
+    return [problem("SqlWithoutWhere", "warning", verbToken, `${verb} without WHERE affects all rows`, [fix])];
+}
+function adjacent(view, left, right) {
+    const a = view.token(left);
+    const b = view.token(right);
+    return a !== undefined && b !== undefined && a.to === b.from;
+}
+/** The comparison operator ending at `last`, as `{ first, operator }`; null for anything else. */
+function operatorEndingAt(view, last) {
+    const token = view.token(last);
+    if (token?.kind !== "symbol")
+        return null;
+    let first = last;
+    while (first > 0 && OPERATOR_CHARACTER.test(view.raw(first - 1)) && adjacent(view, first - 1, first))
+        first -= 1;
+    const start = view.token(first);
+    if (start === undefined)
+        return null;
+    const operator = view.text.slice(start.from, token.to);
+    return COMPARISONS.has(operator) ? { first, operator } : null;
+}
+/** `x = NULL` and `x <> NULL`, which are never true (SqlNullComparison). */
+function nullComparisons(view) {
+    const problems = [];
+    view.tokens.forEach((token, index) => {
+        const clause = view.places[index]?.clause ?? null;
+        if (view.word(index) !== NULL || clause === null || !NULL_COMPARISON_CLAUSES.has(clause))
+            return;
+        const found = operatorEndingAt(view, index - 1);
+        const start = found === null ? undefined : view.token(found.first);
+        if (found === null ||
+            start === undefined ||
+            (found.operator !== "=" && found.operator !== "<>" && found.operator !== "!="))
+            return;
+        const test = found.operator === "=" ? "IS NULL" : "IS NOT NULL";
+        const span = { from: start.from, to: token.to };
+        const fix = { title: `Replace with ${test}`, edits: [{ from: span.from, to: span.to, insert: test }] };
+        problems.push(problem("SqlNullComparison", "warning", span, `'${found.operator} NULL' is never true; use ${test}`, [fix]));
+    });
+    return problems;
+}
+/** The token indices directly in a condition clause's body, a nested group standing as its `(`. */
+function conditionBody(view, keyword) {
+    const { statement } = view;
+    const group = view.places[keyword]?.group ?? NO_GROUP;
+    const body = [];
+    for (let index = keyword + 1; index < view.tokens.length; index += 1) {
+        if (view.places[index]?.group !== group)
+            break;
+        const word = view.word(index);
+        if (word !== null && ((CLAUSE_WORDS.has(word) && word !== ON) || JOIN_WORDS.has(word)))
+            break;
+        if (view.isSymbol(index, CLOSE))
+            break;
+        body.push(index);
+        if (view.isSymbol(index, OPEN))
+            index = statement.closeOf(index);
+    }
+    return body;
+}
+/** A body split at its top-level `AND` and `OR`, a `BETWEEN`'s own `AND` kept in its operand. */
+function conjuncts(view, body) {
+    const parts = [[]];
+    let between = false;
+    for (const index of body) {
+        const word = view.word(index);
+        if (word === BETWEEN)
+            between = true;
+        if ((word === AND && !between) || word === OR) {
+            parts.push([]);
+            continue;
+        }
+        if (word === AND)
+            between = false;
+        parts.at(-1)?.push(index);
+    }
+    return parts.filter((part) => part.length > 0);
+}
+function literalValue(view, index) {
+    const token = view.token(index);
+    const raw = view.raw(index);
+    if (token?.kind === "string" && raw.startsWith("'"))
+        return unquote(raw);
+    if (token?.kind === "word" && NUMBER.test(raw))
+        return Number(raw);
+    return null;
+}
+function compare(left, operator, right) {
+    if (typeof left !== typeof right)
+        return null;
+    switch (operator) {
+        case "=":
+            return left === right;
+        case "<>":
+        case "!=":
+            return left !== right;
+        case "<":
+            return left < right;
+        case ">":
+            return left > right;
+        case "<=":
+            return left <= right;
+        default:
+            return left >= right;
+    }
+}
+/** Whether a conjunct is a constant, and its value when one can be told: `TRUE`, `1 = 1`, `'a' <> 'b'`. */
+function constantValue(view, part) {
+    const [first] = part;
+    if (first === undefined)
+        return undefined;
+    if (part.length === 1) {
+        const word = view.word(first);
+        return word === TRUE ? true : word === FALSE ? false : undefined;
+    }
+    const last = part.at(-1) ?? first;
+    const left = literalValue(view, first);
+    const right = literalValue(view, last);
+    const operator = operatorEndingAt(view, last - 1);
+    if (left === null || right === null || operator === null || operator.first !== first + 1)
+        return undefined;
+    if (part.length !== last - first + 1)
+        return undefined;
+    return compare(left, operator.operator, right);
+}
+function constantFix(view, keyword, part) {
+    const first = part[0];
+    const last = part.at(-1);
+    if (first === undefined || last === undefined)
+        return null;
+    const before = view.word(first - 1);
+    const after = view.word(last + 1);
+    if (before === OR || after === OR)
+        return null;
+    if (before === AND)
+        return removal("Remove condition", view.withLeadingSpace(first - 1, last));
+    const next = view.token(last + 2);
+    if (after === AND && next !== undefined) {
+        return removal("Remove condition", { from: view.token(first)?.from ?? 0, to: next.from });
+    }
+    if (view.word(keyword) === ON)
+        return null;
+    return removal("Remove condition", view.withLeadingSpace(keyword, last));
+}
+/** `WHERE 1 = 1`, `WHERE TRUE` and other literal-only conditions (SqlConstantCondition). */
+function constantConditions(view) {
+    const problems = [];
+    view.tokens.forEach((_, keyword) => {
+        const word = view.word(keyword);
+        if (word === null || !CONDITION_CLAUSES.has(word))
+            return;
+        for (const part of conjuncts(view, conditionBody(view, keyword))) {
+            const value = constantValue(view, part);
+            const start = view.token(part[0] ?? -1);
+            const end = view.token(part.at(-1) ?? -1);
+            if (value === undefined || start === undefined || end === undefined)
+                continue;
+            const text = view.text.slice(start.from, end.to);
+            const message = value === null ? `Condition '${text}' is constant` : `Condition '${text}' is always ${String(value)}`;
+            const fix = value === false ? null : constantFix(view, keyword, part);
+            problems.push(problem("SqlConstantCondition", "warning", { from: start.from, to: end.to }, message, fix === null ? [] : [fix]));
+        }
+    });
+    return problems;
+}
+/** The `)` of a CTE's body, given its name's token. */
+function cteBodyClose(view, nameIndex) {
+    let index = nameIndex + 1;
+    if (view.isSymbol(index, OPEN))
+        index = view.statement.closeOf(index) + 1;
+    if (view.word(index) === AS)
+        index += 1;
+    while (CTE_MODIFIERS.has(view.word(index) ?? ""))
+        index += 1;
+    if (!view.isSymbol(index, OPEN))
+        return null;
+    const close = view.statement.closeOf(index);
+    return view.token(close) === undefined ? null : close;
+}
+function identifierAt(view, index) {
+    const token = view.token(index);
+    if (token === undefined || (token.kind !== "word" && token.kind !== "quoted"))
+        return null;
+    const raw = view.raw(index);
+    return {
+        name: token.kind === "quoted" ? unquote(raw) : raw,
+        quoted: token.kind === "quoted",
+        from: token.from,
+        to: token.to,
+    };
+}
+function cteRemoval(view, nameIndex, close) {
+    const closeToken = view.token(close);
+    const nameToken = view.token(nameIndex);
+    if (closeToken === undefined || nameToken === undefined)
+        return null;
+    const before = view.token(nameIndex - 1);
+    if (view.isSymbol(nameIndex - 1, COMMA) && before !== undefined)
+        return removal("Remove CTE", { from: before.from, to: closeToken.to });
+    const following = view.token(close + 1);
+    if (view.isSymbol(close + 1, COMMA)) {
+        const next = view.token(close + 2);
+        return next === undefined ? null : removal("Remove CTE", { from: nameToken.from, to: next.from });
+    }
+    const withIndex = view.word(nameIndex - 1) === RECURSIVE ? nameIndex - 2 : nameIndex - 1;
+    const withToken = view.token(withIndex);
+    if (view.word(withIndex) !== WITH || withToken === undefined || following === undefined)
+        return null;
+    return removal("Remove CTE", { from: withToken.from, to: following.from });
+}
+/** CTEs nothing outside their own body reads (SqlUnusedCte). */
+function unusedCtes(view) {
+    const problems = [];
+    for (const query of view.queries.keys()) {
+        for (const cte of query.ctes) {
+            const nameIndex = view.indexAt(cte.name.from);
+            const close = cteBodyClose(view, nameIndex);
+            if (nameIndex < 0 || close === null)
+                continue;
+            const used = view.tokens.some((_, index) => {
+                if (index >= nameIndex && index <= close)
+                    return false;
+                const identifier = identifierAt(view, index);
+                return identifier !== null && view.rules.sameIdentifier(identifier, cte.name);
+            });
+            if (used)
+                continue;
+            const fix = cteRemoval(view, nameIndex, close);
+            problems.push(problem("SqlUnusedCte", "warning", cte.name, `CTE '${cte.name.name}' is never used`, fix === null ? [] : [fix]));
+        }
+    }
+    return problems;
+}
+/** Two sources one query refers to by the same name (SqlDuplicateAlias) and an alias equal to its table (SqlRedundantAlias). */
+function aliases(view) {
+    const problems = [];
+    for (const query of view.queries.keys()) {
+        const seen = [];
+        for (const source of query.sources) {
+            if (source.kind === "relation") {
+                const role = view.roleOf(source);
+                if (role === "target" || role === "notRelation")
+                    continue;
+                const alias = source.alias;
+                if (alias !== null && view.rules.sameIdentifier(alias, source.name)) {
+                    const fix = removal("Remove alias", { from: source.name.to, to: alias.to });
+                    problems.push(problem("SqlRedundantAlias", "weak", alias, `Redundant alias '${alias.name}'`, [fix]));
+                }
+            }
+            const reference = referenceName(source);
+            if (reference === null)
+                continue;
+            if (seen.some((other) => view.rules.sameIdentifier(other, reference)))
+                problems.push(problem("SqlDuplicateAlias", "error", reference, `Duplicate table alias '${reference.name}'`));
+            seen.push(reference);
+        }
+    }
+    return problems;
+}
+/** `ASC` in an `ORDER BY` (SqlRedundantOrderingDirection) and `ELSE NULL` before `END` (SqlRedundantElseNull). */
+function redundantWords(view) {
+    const problems = [];
+    view.tokens.forEach((token, index) => {
+        const word = view.word(index);
+        if (word === ASC && view.places[index]?.clause === ORDER_BY) {
+            const fix = removal("Remove ASC", view.withLeadingSpace(index));
+            problems.push(problem("SqlRedundantOrderingDirection", "weak", token, "Redundant ordering direction", [fix]));
+        }
+        const nullToken = view.token(index + 1);
+        if (word === ELSE && view.word(index + 1) === NULL && view.word(index + 2) === END && nullToken !== undefined) {
+            const fix = removal("Remove ELSE NULL", view.withLeadingSpace(index, index + 1));
+            problems.push(problem("SqlRedundantElseNull", "weak", { from: token.from, to: nullToken.to }, "Redundant ELSE NULL", [fix]));
+        }
+    });
+    return problems;
+}
+/** Every inspection here; each runs on an inspected statement only. */
+export const STYLE_INSPECTIONS = [
+    (view) => [...view.queries.keys()].flatMap((query) => insertValues(view, query)),
+    withoutWhere,
+    nullComparisons,
+    constantConditions,
+    unusedCtes,
+    aliases,
+    redundantWords,
+].map((inspection) => (view) => view.inspected ? inspection(view) : []);

package/dist/sql/inspectSyntax.d.ts

@@ -0,0 +1,10 @@
+import type { Problem } from "@tablecraft-app/plugin-api";
+import { type StatementView } from "./inspectContext.js";
+import { type SqlDialectOptions, type Token } from "./tokens.js";
+/** Empty clauses, trailing commas and unbalanced parentheses in one statement. */
+export declare function syntaxProblems(view: StatementView): Problem[];
+/**
+ * A string, quoted name or block comment the text ends inside. Only the last token can be one,
+ * since an unterminated token runs to the end of the text.
+ */
+export declare function unterminatedProblem(text: string, last: Token | undefined, dialect: SqlDialectOptions): Problem | null;

package/dist/sql/inspectSyntax.js

@@ -0,0 +1,179 @@
+import { problem, removal } from "./inspectContext.js";
+import { closingQuote } from "./scope.js";
+import { Lexer } from "./tokens.js";
+const ID = "SqlSyntax";
+const OPEN = "(";
+const CLOSE = ")";
+const COMMA = ",";
+const BY = "BY";
+const SELECT = "SELECT";
+const EXPRESSION_EXPECTED = "Expression expected";
+/** Keywords that start the next clause, so a clause keyword right before one has no body. */
+const CLAUSE_STARTS = new Set([
+    "WHERE",
+    "GROUP",
+    "ORDER",
+    "HAVING",
+    "LIMIT",
+    "OFFSET",
+    "UNION",
+    "INTERSECT",
+    "EXCEPT",
+    "RETURNING",
+    "WINDOW",
+    "FETCH",
+    "FROM",
+    "INTO",
+    "JOIN",
+    "INNER",
+    "LEFT",
+    "RIGHT",
+    "FULL",
+    "CROSS",
+    "NATURAL",
+    "STRAIGHT_JOIN",
+    "SET",
+    "VALUES",
+    "ON",
+    "USING",
+]);
+/** Clause keywords that need an expression after them. */
+const NEEDS_BODY = new Set(["WHERE", "HAVING", "ON", "SET", SELECT]);
+const BY_OWNERS = new Set(["ORDER", "GROUP", "PARTITION"]);
+/** Words between `SELECT` and its list that are not the list. */
+const SELECT_MODIFIERS = new Set([
+    "DISTINCT",
+    "ALL",
+    "DISTINCTROW",
+    "HIGH_PRIORITY",
+    "SQL_CALC_FOUND_ROWS",
+    "SQL_NO_CACHE",
+    "SQL_SMALL_RESULT",
+    "SQL_BIG_RESULT",
+    "SQL_BUFFER_RESULT",
+]);
+const LINE_COMMENT_STARTS = ["--", "#"];
+const BLOCK_COMMENT_END = "*/";
+/** Appended after an unterminated token: a closed token never grows to take it. */
+const PROBE = " x";
+const DOLLAR = "$";
+/** Whether the token at `index` starts the next clause rather than being, say, `LEFT(…)` or `VALUES(…)`. */
+function startsClause(view, index) {
+    const word = view.word(index);
+    return word !== null && CLAUSE_STARTS.has(word) && !view.isSymbol(index + 1, OPEN);
+}
+/** Nothing usable follows `index`: the statement ends, its parentheses close, or the next clause starts. */
+function nothingFollows(view, index) {
+    const next = index + 1;
+    return next >= view.tokens.length || view.isSymbol(next, CLOSE) || startsClause(view, next);
+}
+function emptyClause(view, index) {
+    const word = view.word(index);
+    if (word === null)
+        return null;
+    let first = index;
+    let last = index;
+    if (word === BY) {
+        const owner = view.word(index - 1);
+        if (owner === null || !BY_OWNERS.has(owner))
+            return null;
+        first = index - 1;
+    }
+    else if (!NEEDS_BODY.has(word)) {
+        return null;
+    }
+    if (word === SELECT)
+        while (SELECT_MODIFIERS.has(view.word(last + 1) ?? ""))
+            last += 1;
+    if (!nothingFollows(view, last))
+        return null;
+    const start = view.token(first);
+    const end = view.token(last);
+    if (start === undefined || end === undefined)
+        return null;
+    const label = view.text.slice(start.from, end.to).toUpperCase().replace(/\s+/g, " ");
+    const fixes = [];
+    if (word !== SELECT) {
+        const following = view.token(last + 1);
+        const span = following === undefined || view.isSymbol(last + 1, CLOSE)
+            ? view.withLeadingSpace(first, last)
+            : { from: start.from, to: following.from };
+        fixes.push(removal(`Remove empty ${label} clause`, span));
+    }
+    return problem(ID, "error", { from: start.from, to: end.to }, EXPRESSION_EXPECTED, fixes);
+}
+function trailingComma(view, index) {
+    if (!view.isSymbol(index, COMMA) || !nothingFollows(view, index))
+        return null;
+    const comma = view.token(index);
+    if (comma === undefined)
+        return null;
+    const next = view.word(index + 1);
+    const message = next === null ? "Trailing comma" : `Trailing comma before ${next}`;
+    return problem(ID, "error", comma, message, [removal("Remove trailing comma", comma)]);
+}
+function parentheses(view) {
+    const problems = [];
+    const open = [];
+    view.tokens.forEach((token, index) => {
+        if (view.isSymbol(index, OPEN))
+            open.push(token);
+        else if (view.isSymbol(index, CLOSE) && open.pop() === undefined)
+            problems.push(problem(ID, "error", token, `Unexpected '${CLOSE}'`, [removal(`Remove '${CLOSE}'`, token)]));
+    });
+    for (const token of open) {
+        const fix = { title: `Add closing '${CLOSE}'`, edits: [{ from: view.end, to: view.end, insert: CLOSE }] };
+        problems.push(problem(ID, "error", { from: token.from, to: token.to }, `'${CLOSE}' expected`, [fix]));
+    }
+    return problems;
+}
+/** Empty clauses, trailing commas and unbalanced parentheses in one statement. */
+export function syntaxProblems(view) {
+    const problems = parentheses(view);
+    if (!view.inspected)
+        return problems;
+    for (let index = 0; index < view.tokens.length; index += 1) {
+        const found = emptyClause(view, index) ?? trailingComma(view, index);
+        if (found !== null)
+            problems.push(found);
+    }
+    return problems;
+}
+/** What closes an unterminated token, and what to call it; null for a token that cannot run on. */
+function closer(raw) {
+    if (LINE_COMMENT_STARTS.some((start) => raw.startsWith(start)))
+        return null;
+    if (raw.startsWith("/*"))
+        return { close: BLOCK_COMMENT_END, what: "comment" };
+    if (raw.startsWith(DOLLAR)) {
+        const tag = raw.slice(0, raw.indexOf(DOLLAR, 1) + 1);
+        return { close: tag, what: "string literal" };
+    }
+    const quoteAt = raw.search(/['"`[]/);
+    if (quoteAt < 0)
+        return null;
+    const quote = raw.charAt(quoteAt);
+    return { close: closingQuote(quote), what: quote === "'" ? "string literal" : "quoted identifier" };
+}
+/**
+ * A string, quoted name or block comment the text ends inside. Only the last token can be one,
+ * since an unterminated token runs to the end of the text.
+ */
+export function unterminatedProblem(text, last, dialect) {
+    if (last === undefined || last.to !== text.length)
+        return null;
+    if (last.kind !== "string" && last.kind !== "quoted" && last.kind !== "comment")
+        return null;
+    const raw = text.slice(last.from);
+    const probed = new Lexer(raw + PROBE, dialect).next();
+    if (probed === null || probed.to <= raw.length)
+        return null;
+    const found = closer(raw);
+    if (found === null)
+        return null;
+    const fix = {
+        title: `Add closing ${found.close}`,
+        edits: [{ from: text.length, to: text.length, insert: found.close }],
+    };
+    return problem(ID, "error", last, `Unclosed ${found.what}`, [fix]);
+}

package/dist/sql/layout.d.ts

@@ -0,0 +1,8 @@
+import type { FormatOptions } from "@tablecraft-app/plugin-api";
+import { type SqlDialectOptions } from "./tokens.js";
+export { ALIAS_ALIGN_LIMIT, CASE_INLINE_LIMIT, RIGHT_MARGIN } from "./layoutPrint.js";
+/**
+ * The aligned layout (decision 061), statement by statement. A statement it does not read, or one
+ * whose tokens it would change, goes to `standard` as written (decision 062).
+ */
+export declare function formatAligned(text: string, format: FormatOptions, dialect: SqlDialectOptions, standard: (statement: string) => string): string;