@cloudcare/codemirror-dql 0.0.55 → 0.0.57

package/dist/esm/parser/parser.js

@@ -1,46 +1,2748 @@
-import { syntaxTree } from '@codemirror/language';
+import { Tree } from '@lezer/common';
+import { ensureSyntaxTree, syntaxTreeAvailable } from '@codemirror/language';
+const maxRepairDepth = 8;
+const maxMismatchRepairDepth = 3;
+const analysisBudgetMs = 100;
+const maxDiagnostics = 100;
+const numericClauses = new Map([
+    ['LimitClause', 'LIMIT'],
+    ['OffsetClause', 'OFFSET'],
+    ['SLimitClause', 'SLIMIT'],
+    ['SOffsetClause', 'SOFFSET'],
+]);
+const queryClauseLabels = new Map([
+    ['TargetClause', 'projection'],
+    ['FilterClause', 'WHERE'],
+    ['TimeClause', 'time range'],
+    ['ByClause', 'BY'],
+    ['HavingClause', 'HAVING'],
+    ['OrderClause', 'ORDER BY'],
+    ['LimitClause', 'LIMIT'],
+    ['OffsetClause', 'OFFSET'],
+    ['SOrderClause', 'SORDER BY'],
+    ['SLimitClause', 'SLIMIT'],
+    ['SOffsetClause', 'SOFFSET'],
+]);
+const expressionParents = new Set(['BinaryExpr', 'Expr', 'HavingExpr', 'ProjectionExpr']);
+const commaContextBoundaries = new Set(['CaseExpr', 'Query']);
+export const dqlSyntaxContexts = {
+    DQL: 'DQL query',
+    DQLConditions: 'DQL condition',
+    QueryExpr: 'DQL query',
+    ShowExpr: 'SHOW expression',
+    QueryFragment: 'query fragment',
+    QueryFragmentClause: 'query fragment clause',
+    Query: 'query structure',
+    QueryClause: 'query clause',
+    Namespace: 'namespace',
+    IndexExpr: 'namespace index list',
+    IndexItem: 'namespace index',
+    DataSourceListFragment: 'data source list fragment',
+    DataSourceItemFragment: 'data source fragment',
+    DataSourceList: 'data source list',
+    DataSourceItem: 'data source',
+    QuerySource: 'nested query',
+    OuterFunctionCall: 'outer function call',
+    RawOuterFunctionCallBody: 'outer function arguments',
+    RequiredNumberOuterFunctionCallBody: 'outer function arguments',
+    OptionalNumberOuterFunctionCallBody: 'outer function arguments',
+    FillOuterFunctionCallBody: 'outer function arguments',
+    VariadicOuterFunctionCallBody: 'outer function arguments',
+    EvalExpr: 'eval expression',
+    FunctionCall: 'function call',
+    EvalIdentifier: 'eval function name',
+    RollupIdentifier: 'rollup function name',
+    RollupFunctionCall: 'rollup function call',
+    RollupFunctionCallBody: 'rollup function arguments',
+    RollupArg: 'rollup function argument',
+    FunctionIdentifier: 'function name',
+    OuterFunctionCallBody: 'outer function arguments',
+    OuterArgItem: 'outer function argument',
+    Queted: 'quoted query delimiter',
+    EvalCallBody: 'eval function arguments',
+    FunctionCallBody: 'function arguments',
+    ArgItem: 'function argument',
+    InValue: 'argument value list',
+    SingleExpr: 'expression value',
+    Expr: 'expression',
+    HavingClause: 'HAVING clause',
+    SingleHavingExpr: 'HAVING expression value',
+    HavingExpr: 'HAVING expression',
+    TargetClause: 'projection clause',
+    Projection: 'projection list',
+    ProjectFunc: 'projection function list',
+    ProjectFuncItem: 'projection function',
+    ProjectionFragment: 'projection fragment',
+    ProjectionItemFragment: 'projection fragment item',
+    ProjectionItem: 'projection item',
+    ProjectionFieldFragment: 'projection field fragment',
+    ProjectionField: 'projection field',
+    SingleFieldExpr: 'projection expression value',
+    ProjectionExpr: 'projection expression',
+    AsExpr: 'alias',
+    FilterClause: 'filter clause',
+    InFieldValue: 'filter value list',
+    FieldName: 'field name',
+    JsonField: 'JSON field path',
+    CaseExpr: 'CASE expression',
+    CaseOperand: 'CASE operand',
+    CaseWhenClause: 'CASE WHEN clause',
+    CaseElseClause: 'CASE ELSE clause',
+    CaseCondition: 'CASE condition',
+    CaseFilterExpr: 'CASE filter expression',
+    CasePredicate: 'CASE predicate',
+    CaseValue: 'CASE value',
+    CaseFunctionCall: 'CASE function call',
+    CaseFunctionIdentifier: 'CASE function name',
+    CaseFunctionCallBody: 'CASE function arguments',
+    FilterFragmentExpr: 'filter fragment',
+    ComparisonExpr: 'comparison expression',
+    LogicalFragmentExpr: 'logical filter expression',
+    LogicOp: 'logical operator',
+    NotInSeq: 'NOT IN operator',
+    Operator: 'comparison operator',
+    FilterSubExpr: 'filter subquery',
+    FilterExpr: 'filter expression',
+    BinaryExpr: 'binary expression',
+    TimeClause: 'time range clause',
+    TimeRange: 'time range',
+    TimeExpr: 'time range value',
+    ByClause: 'BY clause',
+    OrderClause: 'ORDER BY clause',
+    SOrderClause: 'SORDER BY clause',
+    LimitClause: 'LIMIT clause',
+    OffsetClause: 'OFFSET clause',
+    SLimitClause: 'SLIMIT clause',
+    SOffsetClause: 'SOFFSET clause',
+    ByExpr: 'grouping expression',
+    ByListExpr: 'grouping field list',
+    ByItem: 'grouping field',
+    FieldCall: 'grouping field function',
+    SingleByExpr: 'grouping expression value',
+    ByMathExpr: 'grouping expression',
+    NestedByMathExpr: 'nested grouping expression',
+};
+const functionCallBodyParents = new Set([
+    'FunctionCallBody',
+    'EvalCallBody',
+    'OuterFunctionCallBody',
+    'RawOuterFunctionCallBody',
+    'RequiredNumberOuterFunctionCallBody',
+    'OptionalNumberOuterFunctionCallBody',
+    'FillOuterFunctionCallBody',
+    'VariadicOuterFunctionCallBody',
+    'RollupFunctionCallBody',
+    'CaseFunctionCallBody',
+]);
 export class Parser {
-    constructor(state) {
-        this.tree = syntaxTree(state);
+    constructor(state, deadline = Date.now() + analysisBudgetMs) {
         this.state = state;
+        this.deadline = deadline;
+        const completeTree = this.getCompleteTree(state);
+        this.tree = completeTree !== null && completeTree !== void 0 ? completeTree : Tree.empty;
+        this.treeComplete = Boolean(completeTree && completeTree.topNode.to >= state.doc.length);
         this.diagnostics = [];
+        this.repairDepth = 0;
+        this.mismatchRepairDepth = 0;
+        this.terminalRepairUsed = false;
+        this.delimiterIssue = undefined;
+        this.quotedQueryDelimiterInfo = undefined;
+        this.caseResultDiagnostics = undefined;
+        this.caseResultRecoveryErrors = new Set();
     }
     getDiagnostics() {
-        return this.diagnostics.sort((a, b) => {
+        const seen = new Set();
+        const diagnostics = [...this.diagnostics]
+            .sort((a, b) => {
             return a.from - b.from;
+        })
+            .filter((diagnostic) => {
+            const key = `${diagnostic.from}:${diagnostic.to}:${diagnostic.message}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
         });
+        if (diagnostics.length <= maxDiagnostics)
+            return diagnostics;
+        const headCount = Math.floor((maxDiagnostics - 1) / 2);
+        const tailCount = maxDiagnostics - headCount - 1;
+        return [
+            ...diagnostics.slice(0, headCount),
+            ...diagnostics.slice(-tailCount),
+            {
+                severity: 'warning',
+                source: 'DQL syntax',
+                message: `too many syntax errors; showing the first ${headCount} and last ${tailCount}`,
+                from: this.state.doc.length,
+                to: this.state.doc.length,
+            },
+        ];
     }
     analyze() {
-        // when you are at the root of the tree, the first node is not `Expr` but a node with no name.
-        // So to be able to iterate other the node relative to the promql node, we have to get the first child at the beginning
-        this.checkAST(this.tree.topNode.firstChild);
-        this.diagnoseAllErrorNodes();
+        const isPrimaryAnalysis = this.repairDepth === 0 && this.mismatchRepairDepth === 0;
+        try {
+            if (this.maskLineComments(this.state.doc.toString()).trim().length === 0) {
+                return;
+            }
+            if (!this.treeComplete || Date.now() >= this.deadline) {
+                if (isPrimaryAnalysis) {
+                    this.pushIncompleteAnalysisWarning();
+                }
+                return;
+            }
+            const delimiterIssue = this.getDelimiterIssue();
+            if (Date.now() >= this.deadline) {
+                if (isPrimaryAnalysis && this.diagnostics.length === 0)
+                    this.pushIncompleteAnalysisWarning();
+                return;
+            }
+            if (isPrimaryAnalysis && !delimiterIssue)
+                this.checkAST(this.tree.topNode.firstChild);
+            if (Date.now() >= this.deadline) {
+                if (isPrimaryAnalysis && this.diagnostics.length === 0)
+                    this.pushIncompleteAnalysisWarning();
+                return;
+            }
+            this.diagnoseAllErrorNodes();
+            if (isPrimaryAnalysis && Date.now() >= this.deadline && this.diagnostics.length === 0)
+                this.pushIncompleteAnalysisWarning();
+        }
+        catch (error) {
+            if (!(error instanceof RangeError))
+                throw error;
+            this.diagnostics.length = 0;
+            if (isPrimaryAnalysis) {
+                this.diagnostics.push({
+                    severity: 'warning',
+                    source: 'DQL syntax',
+                    message: 'syntax analysis stopped because the query is too deeply nested',
+                    from: 0,
+                    to: Math.min(1, this.state.doc.length),
+                });
+            }
+        }
+    }
+    pushIncompleteAnalysisWarning() {
+        const message = 'syntax analysis incomplete; query is too large or deeply nested';
+        if (this.diagnostics.some((diagnostic) => diagnostic.message === message))
+            return;
+        this.diagnostics.push({
+            severity: 'warning',
+            source: 'DQL syntax',
+            message,
+            from: 0,
+            to: Math.min(1, this.state.doc.length),
+        });
+    }
+    getCompleteTree(state) {
+        try {
+            if (syntaxTreeAvailable(state, state.doc.length)) {
+                const ready = ensureSyntaxTree(state, state.doc.length, 0);
+                if (ready && ready.topNode.to >= state.doc.length)
+                    return ready;
+            }
+            const remaining = this.deadline - Date.now();
+            if (remaining <= 0)
+                return null;
+            const tree = ensureSyntaxTree(state, state.doc.length, Math.max(1, Math.ceil(remaining)));
+            return tree && tree.topNode.to >= state.doc.length ? tree : null;
+        }
+        catch (error) {
+            if (error instanceof RangeError)
+                return null;
+            throw error;
+        }
     }
     diagnoseAllErrorNodes() {
+        var _a, _b, _c;
         const cursor = this.tree.cursor();
+        const groups = new Set();
+        const diagnostics = [];
+        const quotedQueryInfo = this.findQuotedQueryDelimiterInfo();
+        for (const fallbackDiagnostic of quotedQueryInfo.fallbackDiagnostics) {
+            if (!diagnostics.some((existing) => this.isSameDiagnostic(existing, fallbackDiagnostic)))
+                diagnostics.push(fallbackDiagnostic);
+        }
+        if (Date.now() >= this.deadline) {
+            this.appendDiagnostics(diagnostics);
+            return;
+        }
+        if (quotedQueryInfo.fallbackRanges.length > 0) {
+            this.appendDiagnostics(diagnostics);
+            return;
+        }
+        const delimiterIssue = this.getDelimiterIssue();
+        if ((delimiterIssue === null || delimiterIssue === void 0 ? void 0 : delimiterIssue.kind) === 'mismatched') {
+            const delimiterDiagnostic = this.makeDelimiterDiagnostic(delimiterIssue);
+            if (!diagnostics.some((existing) => this.isSameDiagnostic(existing, delimiterDiagnostic)))
+                diagnostics.push(delimiterDiagnostic);
+            if (this.mismatchRepairDepth < maxMismatchRepairDepth) {
+                const repairedDiagnostics = delimiterIssue.recovery === 'delete'
+                    ? this.diagnoseAfterDeletion(delimiterIssue.actualFrom, delimiterIssue.actualFrom + 1)
+                    : this.diagnoseAfterReplacement(delimiterIssue.actualFrom, delimiterIssue.actualFrom + 1, delimiterIssue.close);
+                for (const repairedDiagnostic of repairedDiagnostics) {
+                    if (!diagnostics.some((existing) => this.isSameDiagnostic(existing, repairedDiagnostic))) {
+                        diagnostics.push(repairedDiagnostic);
+                    }
+                }
+            }
+            else {
+                const repairedDiagnostics = this.diagnoseAfterBulkDelimiterRecovery(delimiterIssue);
+                for (const repairedDiagnostic of repairedDiagnostics) {
+                    if (!diagnostics.some((existing) => this.isSameDiagnostic(existing, repairedDiagnostic))) {
+                        diagnostics.push(repairedDiagnostic);
+                    }
+                }
+            }
+            this.appendDiagnostics(diagnostics);
+            return;
+        }
+        if ((delimiterIssue === null || delimiterIssue === void 0 ? void 0 : delimiterIssue.kind) === 'unexpectedClosing') {
+            const delimiterDiagnostic = this.makeDelimiterDiagnostic(delimiterIssue);
+            if (!diagnostics.some((existing) => this.isSameDiagnostic(existing, delimiterDiagnostic)))
+                diagnostics.push(delimiterDiagnostic);
+            const repairedDiagnostics = this.mismatchRepairDepth < maxMismatchRepairDepth
+                ? this.diagnoseAfterDeletion(delimiterIssue.actualFrom, delimiterIssue.actualFrom + 1)
+                : this.diagnoseAfterBulkUnexpectedClosingRecovery(delimiterIssue);
+            for (const repairedDiagnostic of repairedDiagnostics) {
+                if (!diagnostics.some((existing) => this.isSameDiagnostic(existing, repairedDiagnostic)))
+                    diagnostics.push(repairedDiagnostic);
+            }
+            this.appendDiagnostics(diagnostics);
+            return;
+        }
+        if (delimiterIssue &&
+            (delimiterIssue.kind === 'quotedQuery' ||
+                (delimiterIssue.kind === 'quote' && (!delimiterIssue.newline || Boolean((_a = delimiterIssue.repairLineBreaks) === null || _a === void 0 ? void 0 : _a.length))))) {
+            diagnostics.push(this.makeDelimiterDiagnostic(delimiterIssue));
+            if (delimiterIssue.kind === 'quote' && delimiterIssue.newline && ((_b = delimiterIssue.repairLineBreaks) === null || _b === void 0 ? void 0 : _b.length)) {
+                const repairs = this.findStringNewlineRepairs(delimiterIssue);
+                for (const repair of repairs.slice(0, maxRepairDepth + 1)) {
+                    const repairDiagnostic = this.makeDiagnosticAt(repair.from, repair.from + 1, 'unescaped newline in string literal', `delimiter:${repair.from}`);
+                    if (!diagnostics.some((existing) => this.isSameDiagnostic(existing, repairDiagnostic)))
+                        diagnostics.push(repairDiagnostic);
+                }
+                const lineBreaks = [...new Set(repairs.flatMap((repair) => repair.lineBreaks))].sort((left, right) => left - right);
+                const repairedDiagnostics = this.diagnoseAfterInsertions(lineBreaks, '\\');
+                for (const repairedDiagnostic of repairedDiagnostics) {
+                    if (!diagnostics.some((existing) => this.isSameDiagnostic(existing, repairedDiagnostic)))
+                        diagnostics.push(repairedDiagnostic);
+                }
+                this.appendDiagnostics(diagnostics);
+                return;
+            }
+            if (this.repairDepth < maxRepairDepth &&
+                (delimiterIssue.repairAt !== undefined || (delimiterIssue.kind === 'quote' && ((_c = delimiterIssue.repairLineBreaks) === null || _c === void 0 ? void 0 : _c.length)))) {
+                const repairedDiagnostics = this.diagnoseAfterInsertion(delimiterIssue.repairAt, delimiterIssue.quote);
+                for (const repairedDiagnostic of repairedDiagnostics) {
+                    if (!diagnostics.some((existing) => this.isSameDiagnostic(existing, repairedDiagnostic))) {
+                        diagnostics.push(repairedDiagnostic);
+                    }
+                }
+            }
+            this.appendDiagnostics(diagnostics);
+            return;
+        }
+        if (delimiterIssue && delimiterIssue.kind !== 'unclosed') {
+            const delimiterDiagnostic = this.makeDelimiterDiagnostic(delimiterIssue);
+            if (!diagnostics.some((existing) => this.isSameDiagnostic(existing, delimiterDiagnostic)))
+                diagnostics.push(delimiterDiagnostic);
+            if (delimiterDiagnostic.group)
+                groups.add(delimiterDiagnostic.group);
+        }
+        for (const caseDiagnostic of this.findCaseResultDiagnostics()) {
+            if (!caseDiagnostic.group || !groups.has(caseDiagnostic.group)) {
+                diagnostics.push(caseDiagnostic);
+                if (caseDiagnostic.group)
+                    groups.add(caseDiagnostic.group);
+            }
+        }
         while (cursor.next()) {
-            // usually there is an error node at the end of the expression when user is typing
-            // so it's not really a useful information to say the expression is wrong.
-            // Hopefully if there is an error node at the end of the tree, checkAST should yell more precisely
-            if (cursor.type.id === 0 && cursor.to !== this.tree.topNode.to) {
-                const node = cursor.node.parent;
-                this.diagnostics.push({
-                    severity: 'error',
-                    message: 'unexpected expression',
-                    from: node ? node.from : cursor.from,
-                    to: node ? node.to : cursor.to,
-                });
+            if (Date.now() >= this.deadline)
+                break;
+            if (!cursor.type.isError) {
+                continue;
+            }
+            if (quotedQueryInfo.fallbackRanges.some((range) => cursor.from === cursor.to ? cursor.from >= range.from && cursor.from <= range.to : cursor.from < range.to && cursor.to > range.from)) {
+                continue;
+            }
+            const diagnostic = this.describeError(cursor.node);
+            if (!diagnostic || (diagnostic.group && groups.has(diagnostic.group))) {
+                continue;
+            }
+            if (diagnostics.some((existing) => existing.from === diagnostic.from && existing.to === diagnostic.to)) {
+                continue;
+            }
+            if (diagnostic.group) {
+                groups.add(diagnostic.group);
+            }
+            diagnostics.push(diagnostic);
+            if (diagnostic.repair) {
+                if (this.repairDepth < maxRepairDepth) {
+                    const repairedDiagnostics = this.diagnoseAfterInsertion(diagnostic.repair.insertAt, diagnostic.repair.text);
+                    for (const repairedDiagnostic of repairedDiagnostics) {
+                        if (!diagnostics.some((existing) => this.isSameDiagnostic(existing, repairedDiagnostic))) {
+                            diagnostics.push(repairedDiagnostic);
+                        }
+                    }
+                }
+                else if (!this.terminalRepairUsed) {
+                    const repairedDiagnostics = this.diagnoseAfterTerminalInsertion(diagnostic);
+                    for (const repairedDiagnostic of repairedDiagnostics) {
+                        if (!diagnostics.some((existing) => this.isSameDiagnostic(existing, repairedDiagnostic))) {
+                            diagnostics.push(repairedDiagnostic);
+                        }
+                    }
+                }
+                break;
             }
         }
+        this.appendDiagnostics(diagnostics);
     }
-    checkAST(node) { }
-    addDiagnostic(node, msg) {
-        this.diagnostics.push({
-            severity: 'error',
-            message: msg,
-            from: node.from,
-            to: node.to,
+    describeError(node) {
+        var _a;
+        const delimiterIssue = this.getDelimiterIssue();
+        if (delimiterIssue && delimiterIssue.kind !== 'unclosed' && this.isRelatedDelimiterError(node, delimiterIssue)) {
+            return null;
+        }
+        const parent = node.parent;
+        if (!parent) {
+            return this.makeDiagnostic(node, 'incomplete DQL query');
+        }
+        const parentName = parent.name;
+        const previous = this.siblingSkippingLineComments(node, 'previous');
+        const next = this.siblingSkippingLineComments(node, 'next');
+        const previousText = previous ? this.nodeText(previous) : '';
+        const errorText = this.nodeText(node);
+        const group = `${parentName}:${parent.from}:${parent.to}:${node.from}:${node.to}`;
+        const unknownFunctionDiagnostic = this.describeUnknownFunction(node);
+        if (unknownFunctionDiagnostic)
+            return unknownFunctionDiagnostic;
+        const commaRunDiagnostic = this.describeConsecutiveCommaError(node, parent);
+        if (commaRunDiagnostic)
+            return commaRunDiagnostic;
+        if (parentName === 'Namespace') {
+            if (errorText === ':') {
+                return this.makeDiagnosticRepairing(node, 'expected "::" after namespace', node.to, ':', `Namespace:${parent.from}:${parent.to}`);
+            }
+            return this.makeDiagnostic(node, 'expected "::" after namespace', `Namespace:${parent.from}:${parent.to}`);
+        }
+        if (parentName === 'Query' && node.from === node.to && (previous === null || previous === void 0 ? void 0 : previous.name) === 'Namespace' && !this.containsError(previous)) {
+            const hasSingleColon = this.state.sliceDoc(node.from, node.from + 1) === ':';
+            return this.makeDiagnosticRepairingAt(node.from, node.from + (hasSingleColon ? 1 : 0), 'expected "::" after namespace', node.from + (hasSingleColon ? 1 : 0), hasSingleColon ? ':' : '::', `Namespace:${previous.from}:${previous.to}`);
+        }
+        if (parentName === 'Query' && node.from === node.to && (previous === null || previous === void 0 ? void 0 : previous.name) === 'DColon') {
+            return this.makeDiagnostic(node, 'data source expected after "::"', group);
+        }
+        if (parentName === 'DataSourceItem') {
+            return this.makeDiagnostic(node, 'data source expected after "::"', group);
+        }
+        if (parentName === 'DataSourceList') {
+            if (node.from === node.to && (previous === null || previous === void 0 ? void 0 : previous.name) === 'DataSourceItem' && (next === null || next === void 0 ? void 0 : next.name) === 'DataSourceItem') {
+                if (this.isAdjacentToComma(node, parent)) {
+                    return this.makeDiagnostic(node, 'data source expected after ","', group);
+                }
+                if (this.looksLikeProjectionAfterMissingColon(next)) {
+                    return this.makeDiagnosticRepairing(node, 'expected ":" after data source', node.from, ':', group);
+                }
+                return this.makeDiagnostic(node, 'expected "," between data sources', group);
+            }
+            if (this.isAdjacentToComma(node, parent)) {
+                return this.makeDiagnostic(node, 'data source expected after ","', group);
+            }
+            return this.makeUnexpectedTokenDiagnostic(node, dqlSyntaxContexts.DataSourceList, group);
+        }
+        if (parentName === 'TargetClause') {
+            if (node.from === node.to && (previous === null || previous === void 0 ? void 0 : previous.name) === 'Comma') {
+                return this.makeDiagnostic(node, 'projection expected after ":"', group);
+            }
+            return this.makeUnexpectedTokenDiagnostic(node, dqlSyntaxContexts.TargetClause, group);
+        }
+        if (parentName === 'Projection') {
+            if (this.isCommaSequence(errorText) || this.isCommaOnlyList(parent)) {
+                return this.makeDiagnostic(node, 'projection item expected between commas', this.commaSequenceGroup(parent));
+            }
+            if (errorText === ',' && !previous) {
+                return this.makeDiagnostic(node, 'projection item expected before ","', group);
+            }
+            if (this.isAdjacentToComma(node, parent)) {
+                return this.makeDiagnostic(node, 'projection item expected after ","', group);
+            }
+            if (node.from === node.to && (previous === null || previous === void 0 ? void 0 : previous.name) === 'ProjectionItem' && (next === null || next === void 0 ? void 0 : next.name) === 'ProjectionItem') {
+                return this.makeDiagnostic(node, 'expected "," between projection items', group);
+            }
+            return this.makeUnexpectedTokenDiagnostic(node, 'projection', group);
+        }
+        if (parentName === 'ProjectionField' && (previous === null || previous === void 0 ? void 0 : previous.name) === 'As') {
+            return this.makeDiagnostic(node, 'alias expected after "AS"', group);
+        }
+        if (parentName === 'ProjectionField' && node.from === node.to && previous && (next === null || next === void 0 ? void 0 : next.name) === 'AsExpr') {
+            if (this.maskLineComments(this.state.sliceDoc(next.to)).trimStart().startsWith('(')) {
+                return null;
+            }
+            return this.makeDiagnostic(node, 'expected "AS" before projection alias', group);
+        }
+        if (parentName === 'OuterFunctionCall') {
+            return this.makeUnexpectedTokenDiagnostic(node, dqlSyntaxContexts.OuterFunctionCall, group);
+        }
+        if (functionCallBodyParents.has(parentName)) {
+            if (parentName === 'OuterFunctionCallBody' && this.hasErroredSibling(parent)) {
+                return null;
+            }
+            if (this.isCommaSequence(errorText) || this.isCommaOnlyList(parent)) {
+                return this.makeDiagnostic(node, 'function argument expected between commas', this.commaSequenceGroup(parent));
+            }
+            if (errorText === ',' && !previous) {
+                return this.makeDiagnostic(node, 'function argument expected before ","', group);
+            }
+            if (this.isAdjacentToComma(node, parent)) {
+                return this.makeDiagnostic(node, 'function argument expected after ","', group);
+            }
+            if (node.from === this.tree.topNode.to) {
+                const issue = this.getDelimiterIssue();
+                if ((issue === null || issue === void 0 ? void 0 : issue.kind) === 'unclosed') {
+                    return this.makeDelimiterDiagnostic(issue);
+                }
+            }
+            return this.makeUnexpectedTokenDiagnostic(node, 'function call', group);
+        }
+        if (parentName === 'ArgItem' && node.from === node.to) {
+            if ((previous === null || previous === void 0 ? void 0 : previous.name) === 'EqlSingle') {
+                return this.makeDiagnostic(node, 'function argument value expected after "="', group);
+            }
+            return this.makeDiagnostic(node, 'expected "," between function arguments', group);
+        }
+        if (parentName === 'InValue' || parentName === 'InFieldValue') {
+            const context = parentName === 'InValue' ? 'argument value' : 'filter value';
+            if (this.isCommaSequence(errorText) || this.isCommaOnlyList(parent)) {
+                return this.makeDiagnostic(node, `${context} expected between commas`, this.commaSequenceGroup(parent));
+            }
+            if (errorText === ',' && !previous) {
+                return this.makeDiagnostic(node, `${context} expected before ","`, group);
+            }
+            if (this.isAdjacentToComma(node, parent)) {
+                return this.makeDiagnostic(node, `${context} expected after ","`, group);
+            }
+            return this.makeUnexpectedTokenDiagnostic(node, dqlSyntaxContexts[parentName], group);
+        }
+        if (parentName === 'IndexExpr' || parentName === 'IndexItem') {
+            if (this.isCommaSequence(errorText)) {
+                return this.makeDiagnostic(node, 'namespace index expected between commas', group);
+            }
+            if (errorText === ',' && !previous) {
+                return this.makeDiagnostic(node, 'namespace index expected before ","', group);
+            }
+            if (this.isAdjacentToComma(node, parent)) {
+                return this.makeDiagnostic(node, 'namespace index expected after ","', group);
+            }
+            return this.makeUnexpectedTokenDiagnostic(node, 'namespace index list', group);
+        }
+        if (parentName === 'ByListExpr') {
+            if (this.isCommaSequence(errorText)) {
+                return this.makeDiagnostic(node, 'grouping field expected between commas', group);
+            }
+            if (errorText === ',' && !previous) {
+                return this.makeDiagnostic(node, 'grouping field expected before ","', group);
+            }
+            if (this.isAdjacentToComma(node, parent)) {
+                return this.makeDiagnostic(node, 'grouping field expected after ","', group);
+            }
+            return this.makeUnexpectedTokenDiagnostic(node, 'grouping field list', group);
+        }
+        if (parentName === 'ByExpr' && errorText === ',') {
+            return this.makeDiagnostic(node, 'grouping field expected before ","', group);
+        }
+        if (expressionParents.has(parentName)) {
+            if (previous && this.isOperator(previous)) {
+                return this.makeDiagnostic(node, `right-hand expression expected after "${previousText}"`, group);
+            }
+            return this.makeUnexpectedTokenDiagnostic(node, 'expression', group);
+        }
+        const caseWhenClause = this.findAncestor(parent, 'CaseWhenClause');
+        if (caseWhenClause) {
+            const missingCondition = /^\s*when\s+(then)\b/i.exec(this.maskLineComments(this.nodeText(caseWhenClause)));
+            if (missingCondition) {
+                const thenOffset = missingCondition.index + missingCondition[0].toLowerCase().lastIndexOf('then');
+                return this.makeDiagnosticAt(caseWhenClause.from + thenOffset, caseWhenClause.from + thenOffset + 4, 'CASE condition expected after "WHEN"', this.caseGroup(caseWhenClause));
+            }
+        }
+        if (parentName === 'CaseCondition') {
+            return this.makeDiagnostic(node, 'expected "THEN" after CASE condition', this.caseGroup(parent));
+        }
+        if (parentName === 'CaseWhenClause') {
+            if ((previous === null || previous === void 0 ? void 0 : previous.name) === 'Then') {
+                return this.makeDiagnostic(node, 'CASE result expected after "THEN"', this.caseGroup(parent));
+            }
+            if ((previous === null || previous === void 0 ? void 0 : previous.name) === 'CaseCondition' && this.containsError(previous)) {
+                return null;
+            }
+            return this.makeDiagnostic(node, 'expected "THEN" after CASE condition', this.caseGroup(parent));
+        }
+        if (parentName === 'CaseElseClause') {
+            return this.makeDiagnostic(node, 'CASE result expected after "ELSE"', this.caseGroup(parent));
+        }
+        if (parentName === 'CaseExpr') {
+            if (this.caseResultRecoveryErrors.has(this.nodeRangeKey(node)))
+                return null;
+            if (errorText)
+                return this.makeUnexpectedTokenDiagnostic(node, dqlSyntaxContexts.CaseExpr, group);
+            if (previous && this.containsError(previous)) {
+                return null;
+            }
+            if ((previous === null || previous === void 0 ? void 0 : previous.name) === 'CaseOperand') {
+                return this.makeDiagnostic(node, 'CASE expression requires at least one "WHEN" clause', this.caseGroup(parent));
+            }
+            return this.makeDiagnostic(node, 'expected "END" to close CASE expression', this.caseGroup(parent));
+        }
+        const numericKeyword = numericClauses.get(parentName);
+        if (numericKeyword) {
+            return this.makeDiagnostic(node, `number expected after "${numericKeyword}"`, group);
+        }
+        if (parentName === 'ByClause') {
+            return this.makeDiagnostic(node, 'grouping field expected after "BY"', group);
+        }
+        if (parentName === 'HavingClause') {
+            return this.makeDiagnostic(node, 'expression expected after "HAVING"', group);
+        }
+        if (parentName === 'OrderClause' || parentName === 'SOrderClause') {
+            const keyword = parentName === 'OrderClause' ? 'ORDER' : 'SORDER';
+            if (!parent.getChild('By')) {
+                return this.makeDiagnostic(node, `expected "BY" after "${keyword}"`, group);
+            }
+            return this.makeDiagnostic(node, `sort field expected after "${keyword} BY"`, group);
+        }
+        if (parentName === 'RollupIdentifier') {
+            const timeClause = this.findAncestor(parent, 'TimeClause');
+            let child = (_a = timeClause === null || timeClause === void 0 ? void 0 : timeClause.firstChild) !== null && _a !== void 0 ? _a : null;
+            while (child) {
+                if (child.type.isError)
+                    return null;
+                child = child.nextSibling;
+            }
+        }
+        if (parentName === 'TimeClause') {
+            if (!this.nodeText(parent).trimEnd().endsWith(']')) {
+                return this.makeDiagnostic(node, 'expected "]" to close time range', group);
+            }
+            return this.makeUnexpectedTokenDiagnostic(node, dqlSyntaxContexts.TimeClause, group);
+        }
+        const timeClause = this.findAncestor(parent, 'TimeClause');
+        if (timeClause && /^\[\s*]$/.test(this.maskLineComments(this.nodeText(timeClause)))) {
+            return this.makeDiagnostic(node, 'time range value expected between "[" and "]"', `TimeClause:${timeClause.from}:${timeClause.to}`);
+        }
+        if (parentName === 'FilterClause') {
+            if (this.isCommaSequence(errorText) || this.isCommaOnlyList(parent)) {
+                return this.makeDiagnostic(node, 'filter expression expected between commas', this.commaSequenceGroup(parent));
+            }
+            if (errorText === ',' && !previous) {
+                return this.makeDiagnostic(node, 'filter expression expected before ","', group);
+            }
+            if (this.isAdjacentToComma(node, parent)) {
+                return this.makeDiagnostic(node, 'filter expression expected after ","', group);
+            }
+            if (node.from === node.to && (previous === null || previous === void 0 ? void 0 : previous.name) === 'FilterExpr' && (next === null || next === void 0 ? void 0 : next.name) === 'FilterExpr') {
+                return this.makeDiagnostic(node, 'comparison operator expected between filter expressions', group);
+            }
+            if (!this.nodeText(parent).trimEnd().endsWith('}')) {
+                return this.makeDiagnostic(node, 'expected "}" to close filter clause', group);
+            }
+            return this.makeUnexpectedTokenDiagnostic(node, dqlSyntaxContexts.FilterClause, group);
+        }
+        if (node.from === this.tree.topNode.to) {
+            const issue = this.getDelimiterIssue();
+            if ((issue === null || issue === void 0 ? void 0 : issue.kind) === 'unclosed') {
+                return this.makeDelimiterDiagnostic(issue);
+            }
+        }
+        const context = this.findSyntaxContext(parent);
+        return this.makeUnexpectedTokenDiagnostic(node, context, group);
+    }
+    makeUnexpectedTokenDiagnostic(node, context, group) {
+        const text = this.nodeText(node);
+        const rawToken = text.length > 20 ? `${text.slice(0, 20)}...` : text;
+        const token = rawToken.replace(/"/g, '\\"');
+        return this.makeDiagnostic(node, token ? `unexpected token "${token}" in ${context}` : `incomplete ${context}`, group);
+    }
+    findSyntaxContext(node) {
+        let current = node;
+        while (current) {
+            const context = dqlSyntaxContexts[current.name];
+            if (context) {
+                return context;
+            }
+            current = current.parent;
+        }
+        return dqlSyntaxContexts.DQL;
+    }
+    makeDiagnostic(node, message, group) {
+        return this.makeDiagnosticAt(node.from, node.to, message, group);
+    }
+    makeDiagnosticRepairing(node, message, insertAt, text, group) {
+        return this.makeDiagnosticRepairingAt(node.from, node.to, message, insertAt, text, group);
+    }
+    makeDiagnosticRepairingAt(from, to, message, insertAt, text, group) {
+        return {
+            ...this.makeDiagnosticAt(from, to, message, group),
+            repair: { insertAt, text },
+        };
+    }
+    diagnoseAfterInsertion(insertAt, text) {
+        const repairedState = this.state.update({ changes: { from: insertAt, insert: text }, filter: false }).state;
+        if (repairedState.doc.length !== this.state.doc.length + text.length) {
+            return [];
+        }
+        const repairedParser = new Parser(repairedState, this.deadline);
+        repairedParser.repairDepth = this.repairDepth + 1;
+        repairedParser.mismatchRepairDepth = this.mismatchRepairDepth;
+        repairedParser.terminalRepairUsed = this.terminalRepairUsed;
+        repairedParser.analyze();
+        return repairedParser.getDiagnostics().map((diagnostic) => ({
+            ...diagnostic,
+            from: this.mapRepairedPosition(diagnostic.from, insertAt, text.length),
+            to: this.mapRepairedPosition(diagnostic.to, insertAt, text.length),
+        }));
+    }
+    diagnoseAfterInsertions(insertAts, text) {
+        const positions = [...new Set(insertAts)].sort((left, right) => left - right);
+        if (positions.length === 0)
+            return [];
+        const repairedState = this.state.update({
+            changes: positions.map((from) => ({ from, insert: text })),
+            filter: false,
+        }).state;
+        if (repairedState.doc.length !== this.state.doc.length + positions.length * text.length) {
+            return [];
+        }
+        const repairedParser = new Parser(repairedState, this.deadline);
+        repairedParser.repairDepth = this.repairDepth + 1;
+        repairedParser.mismatchRepairDepth = this.mismatchRepairDepth;
+        repairedParser.terminalRepairUsed = this.terminalRepairUsed;
+        repairedParser.analyze();
+        return repairedParser.getDiagnostics().map((diagnostic) => ({
+            ...diagnostic,
+            from: this.mapRepairedPositionAfterInsertions(diagnostic.from, positions, text.length),
+            to: this.mapRepairedPositionAfterInsertions(diagnostic.to, positions, text.length),
+        }));
+    }
+    diagnoseAfterReplacement(from, to, text) {
+        const repairedState = this.state.update({ changes: { from, to, insert: text }, filter: false }).state;
+        if (repairedState.doc.length !== this.state.doc.length - (to - from) + text.length) {
+            return [];
+        }
+        const repairedParser = new Parser(repairedState, this.deadline);
+        repairedParser.repairDepth = this.repairDepth + 1;
+        repairedParser.mismatchRepairDepth = this.mismatchRepairDepth + 1;
+        repairedParser.terminalRepairUsed = this.terminalRepairUsed;
+        repairedParser.analyze();
+        return repairedParser.getDiagnostics();
+    }
+    diagnoseAfterDeletion(from, to) {
+        const repairedState = this.state.update({ changes: { from, to, insert: '' }, filter: false }).state;
+        const deletedLength = to - from;
+        if (repairedState.doc.length !== this.state.doc.length - deletedLength) {
+            return [];
+        }
+        const repairedParser = new Parser(repairedState, this.deadline);
+        repairedParser.repairDepth = this.repairDepth + 1;
+        repairedParser.mismatchRepairDepth = this.mismatchRepairDepth + 1;
+        repairedParser.terminalRepairUsed = this.terminalRepairUsed;
+        repairedParser.analyze();
+        return repairedParser.getDiagnostics().map((diagnostic) => ({
+            ...diagnostic,
+            from: diagnostic.from < from ? diagnostic.from : diagnostic.from + deletedLength,
+            to: diagnostic.to <= from && diagnostic.from < from ? diagnostic.to : diagnostic.to + deletedLength,
+        }));
+    }
+    diagnoseAfterBulkDelimiterRecovery(issue) {
+        var _a;
+        const firstTransaction = this.state.update({
+            changes: {
+                from: issue.actualFrom,
+                to: issue.actualFrom + 1,
+                insert: issue.recovery === 'delete' ? '' : issue.close,
+            },
+            filter: false,
+        });
+        const bulkChanges = this.findBulkDelimiterRecoveryChanges(firstTransaction.state);
+        if (bulkChanges === null)
+            return [];
+        const bulkTransaction = bulkChanges.length > 0 ? firstTransaction.state.update({ changes: bulkChanges, filter: false }) : null;
+        const repairedState = (_a = bulkTransaction === null || bulkTransaction === void 0 ? void 0 : bulkTransaction.state) !== null && _a !== void 0 ? _a : firstTransaction.state;
+        const repairedParser = new Parser(repairedState, this.deadline);
+        repairedParser.repairDepth = this.repairDepth + 1;
+        repairedParser.mismatchRepairDepth = this.mismatchRepairDepth + 1;
+        repairedParser.terminalRepairUsed = this.terminalRepairUsed;
+        repairedParser.analyze();
+        let diagnostics = repairedParser.getDiagnostics();
+        if (bulkTransaction) {
+            diagnostics = this.mapDiagnosticsThroughChanges(diagnostics, bulkTransaction.changes);
+        }
+        return this.mapDiagnosticsThroughChanges(diagnostics, firstTransaction.changes);
+    }
+    diagnoseAfterBulkUnexpectedClosingRecovery(issue) {
+        var _a;
+        const firstTransaction = this.state.update({
+            changes: { from: issue.actualFrom, to: issue.actualFrom + 1, insert: '' },
+            filter: false,
         });
+        const bulkChanges = this.findBulkDelimiterRecoveryChanges(firstTransaction.state);
+        if (bulkChanges === null)
+            return [];
+        const bulkTransaction = bulkChanges.length > 0 ? firstTransaction.state.update({ changes: bulkChanges, filter: false }) : null;
+        const repairedState = (_a = bulkTransaction === null || bulkTransaction === void 0 ? void 0 : bulkTransaction.state) !== null && _a !== void 0 ? _a : firstTransaction.state;
+        const repairedParser = new Parser(repairedState, this.deadline);
+        repairedParser.repairDepth = this.repairDepth + 1;
+        repairedParser.mismatchRepairDepth = this.mismatchRepairDepth + 1;
+        repairedParser.terminalRepairUsed = this.terminalRepairUsed;
+        repairedParser.analyze();
+        let diagnostics = repairedParser.getDiagnostics();
+        if (bulkTransaction)
+            diagnostics = this.mapDiagnosticsThroughChanges(diagnostics, bulkTransaction.changes);
+        return this.mapDiagnosticsThroughChanges(diagnostics, firstTransaction.changes);
+    }
+    diagnoseAfterTerminalInsertion(diagnostic) {
+        var _a;
+        if (!diagnostic.repair)
+            return [];
+        const firstTransaction = this.state.update({
+            changes: { from: diagnostic.repair.insertAt, insert: diagnostic.repair.text },
+            filter: false,
+        });
+        const matchingRepairs = this.findMatchingRepairs(firstTransaction.state, diagnostic.message);
+        if (diagnostic.message === 'expected "::" after namespace') {
+            for (const from of this.findLikelyNamespaceSeparatorInsertions(firstTransaction.state.doc.toString())) {
+                matchingRepairs.push({ from, insert: ':' });
+            }
+        }
+        const uniqueRepairs = matchingRepairs
+            .sort((left, right) => left.from - right.from)
+            .filter((repair, index, repairs) => index === 0 || repair.from !== repairs[index - 1].from || repair.insert !== repairs[index - 1].insert);
+        const bulkTransaction = uniqueRepairs.length > 0
+            ? firstTransaction.state.update({
+                changes: uniqueRepairs,
+                filter: false,
+            })
+            : null;
+        const repairedState = (_a = bulkTransaction === null || bulkTransaction === void 0 ? void 0 : bulkTransaction.state) !== null && _a !== void 0 ? _a : firstTransaction.state;
+        const repairedParser = new Parser(repairedState, this.deadline);
+        repairedParser.repairDepth = this.repairDepth + 1;
+        repairedParser.mismatchRepairDepth = this.mismatchRepairDepth;
+        repairedParser.terminalRepairUsed = true;
+        repairedParser.analyze();
+        let diagnostics = repairedParser.getDiagnostics();
+        if (bulkTransaction) {
+            diagnostics = this.mapDiagnosticsThroughChanges(diagnostics, bulkTransaction.changes);
+        }
+        return this.mapDiagnosticsThroughChanges(diagnostics, firstTransaction.changes);
+    }
+    findStringNewlineRepairs(issue) {
+        var _a;
+        const text = this.state.doc.toString();
+        const repairs = new Map();
+        if ((_a = issue.repairLineBreaks) === null || _a === void 0 ? void 0 : _a.length)
+            repairs.set(issue.from, issue.repairLineBreaks);
+        const cursor = this.tree.cursor();
+        while (cursor.next()) {
+            if (cursor.name !== 'StringLiteral' || cursor.from >= cursor.to || text[cursor.to] !== '\n')
+                continue;
+            if (this.findAncestor(cursor.node.parent, 'IndexItem'))
+                continue;
+            const quote = text[cursor.from];
+            if (quote !== '"' && quote !== "'")
+                continue;
+            const recovery = this.findStringNewlineRecovery(text, cursor.from + 1, quote);
+            if (recovery === null || recovery === void 0 ? void 0 : recovery.lineBreaks.length)
+                repairs.set(cursor.from, recovery.lineBreaks);
+        }
+        const transparent = this.findLexicalQuotedQueryWrapperDelimiters(this.tree, text);
+        for (let index = 0; index < text.length; index += 1) {
+            if (transparent.has(index))
+                continue;
+            const char = text[index];
+            if (char === '#') {
+                while (index + 1 < text.length && text[index + 1] !== '\n')
+                    index += 1;
+                continue;
+            }
+            if (char.charCodeAt(0) === 96) {
+                const closing = text.indexOf(char, index + 1);
+                if (closing < 0)
+                    break;
+                index = closing;
+                continue;
+            }
+            if (char !== '"' && char !== "'")
+                continue;
+            const recovery = this.findStringNewlineRecovery(text, index + 1, char);
+            if (!recovery)
+                break;
+            if (recovery.lineBreaks.length)
+                repairs.set(index, recovery.lineBreaks);
+            index = recovery.end - 1;
+        }
+        return [...repairs.entries()].map(([from, lineBreaks]) => ({ from, lineBreaks })).sort((left, right) => left.from - right.from);
+    }
+    findLexicalQuotedQueryWrapperDelimiters(tree, text) {
+        const transparent = new Set();
+        const cursor = tree.cursor();
+        while (cursor.next()) {
+            if (cursor.name !== 'OuterArgItem' || !cursor.node.getChild('Query'))
+                continue;
+            const opening = cursor.node.getChildren('Queted')[0];
+            if (!opening)
+                continue;
+            const quote = text[opening.from];
+            const closing = this.findLexicalQuotedQueryClosing(text, opening.from, quote);
+            if (closing !== null) {
+                transparent.add(opening.from);
+                transparent.add(closing);
+            }
+        }
+        return transparent;
+    }
+    findLexicalQuotedQueryClosing(text, opening, wrapperQuote) {
+        const pairs = { '(': ')', '[': ']', '{': '}' };
+        const closers = new Set(Object.values(pairs));
+        const stack = [];
+        let quote = '';
+        let escaped = false;
+        let inComment = false;
+        for (let index = opening + 1; index < text.length; index += 1) {
+            if (Date.now() >= this.deadline)
+                return null;
+            const char = text[index];
+            if (inComment) {
+                if (char === '\n')
+                    inComment = false;
+                continue;
+            }
+            if (quote) {
+                if (escaped) {
+                    escaped = false;
+                }
+                else if (char === '\\' && quote.charCodeAt(0) !== 96) {
+                    escaped = true;
+                }
+                else if (char === quote) {
+                    quote = '';
+                }
+                continue;
+            }
+            const following = char === wrapperQuote ? this.nextNonTriviaCharacter(text, index + 1) : '';
+            if (following === ')' || following === ',')
+                return index;
+            if (char === '"' || char === "'" || char.charCodeAt(0) === 96) {
+                quote = char;
+            }
+            else if (char === '#') {
+                inComment = true;
+            }
+            else if (pairs[char]) {
+                stack.push(pairs[char]);
+            }
+            else if (closers.has(char)) {
+                if (stack[stack.length - 1] === char)
+                    stack.pop();
+                else if (stack.length > 0)
+                    stack.pop();
+            }
+        }
+        return null;
+    }
+    nextNonTriviaCharacter(text, start) {
+        let inComment = false;
+        for (let index = start; index < text.length; index += 1) {
+            if (Date.now() >= this.deadline)
+                return '';
+            const char = text[index];
+            if (inComment) {
+                if (char === '\n')
+                    inComment = false;
+            }
+            else if (char === '#') {
+                inComment = true;
+            }
+            else if (!/\s/.test(char)) {
+                return char;
+            }
+        }
+        return '';
+    }
+    findMatchingRepairs(state, message) {
+        const candidate = new Parser(state, this.deadline);
+        if (!candidate.treeComplete)
+            return [];
+        const repairs = [];
+        const cursor = candidate.tree.cursor();
+        while (cursor.next()) {
+            if (!cursor.type.isError)
+                continue;
+            const described = candidate.describeError(cursor.node);
+            if ((described === null || described === void 0 ? void 0 : described.message) === message && described.repair) {
+                repairs.push({ from: described.repair.insertAt, insert: described.repair.text });
+            }
+        }
+        return repairs;
+    }
+    mapDiagnosticsThroughChanges(diagnostics, changes) {
+        const inverse = changes.invertedDesc;
+        return diagnostics.map((diagnostic) => ({
+            ...diagnostic,
+            from: inverse.mapPos(diagnostic.from, 1),
+            to: inverse.mapPos(diagnostic.to, diagnostic.from === diagnostic.to ? 1 : -1),
+        }));
+    }
+    findLikelyNamespaceSeparatorInsertions(text) {
+        const masked = this.maskStringsAndLineComments(text);
+        const pattern = /(?:^|\()\s*[A-Za-z_-][A-Za-z0-9_-]*(?:\([^()\n]*\))?\s*:(?!:)/g;
+        const insertions = [];
+        let match = pattern.exec(masked);
+        while (match) {
+            insertions.push(match.index + match[0].lastIndexOf(':') + 1);
+            match = pattern.exec(masked);
+        }
+        return [...new Set(insertions)];
+    }
+    findBulkDelimiterRecoveryChanges(state) {
+        var _a, _b, _c;
+        if (Date.now() >= this.deadline)
+            return null;
+        const text = state.doc.toString();
+        const candidate = new Parser(state, this.deadline);
+        if (!candidate.treeComplete)
+            return null;
+        const transparent = candidate.findQuotedQueryDelimiterInfo().transparent;
+        const pairs = { '(': ')', '[': ']', '{': '}' };
+        const closers = new Set(Object.values(pairs));
+        const tokens = [];
+        let quote = '';
+        let escaped = false;
+        let inComment = false;
+        for (let index = 0; index < text.length; index += 1) {
+            if (Date.now() >= this.deadline)
+                return null;
+            const char = text[index];
+            if (transparent.has(index))
+                continue;
+            if (inComment) {
+                if (char === '\n')
+                    inComment = false;
+                continue;
+            }
+            if (quote) {
+                if (escaped) {
+                    escaped = false;
+                }
+                else if (char === '\\' && quote.charCodeAt(0) !== 96) {
+                    escaped = true;
+                }
+                else if (char === quote) {
+                    quote = '';
+                }
+                else if (char === '\n' && quote.charCodeAt(0) !== 96) {
+                    quote = '';
+                }
+                continue;
+            }
+            if (char === '"' || char === "'" || char.charCodeAt(0) === 96) {
+                quote = char;
+            }
+            else if (char === '#') {
+                inComment = true;
+            }
+            else if (pairs[char] || closers.has(char)) {
+                tokens.push({ char, from: index });
+            }
+        }
+        const stack = [];
+        const stackCloserCounts = new Map();
+        const futureCloserCounts = new Map();
+        const changes = [];
+        for (const token of tokens) {
+            if (Date.now() >= this.deadline)
+                return null;
+            if (pairs[token.char]) {
+                const closer = pairs[token.char];
+                stack.push(closer);
+                stackCloserCounts.set(closer, ((_a = stackCloserCounts.get(closer)) !== null && _a !== void 0 ? _a : 0) + 1);
+                futureCloserCounts.clear();
+                continue;
+            }
+            const expected = stack[stack.length - 1];
+            if (!expected) {
+                changes.push({ from: token.from, to: token.from + 1, insert: '' });
+                continue;
+            }
+            if (token.char === expected) {
+                stack.pop();
+                stackCloserCounts.set(expected, ((_b = stackCloserCounts.get(expected)) !== null && _b !== void 0 ? _b : 1) - 1);
+                futureCloserCounts.clear();
+                continue;
+            }
+            const sameCloserDepth = (_c = stackCloserCounts.get(expected)) !== null && _c !== void 0 ? _c : 0;
+            let futureCloserCount = futureCloserCounts.get(expected);
+            if (futureCloserCount === undefined) {
+                const countedClosers = this.countFutureClosersAtCurrentDepth(text, token.from + 1, expected, transparent);
+                if (countedClosers === null)
+                    return null;
+                futureCloserCount = countedClosers;
+                futureCloserCounts.set(expected, countedClosers);
+            }
+            if (futureCloserCount >= sameCloserDepth) {
+                changes.push({ from: token.from, to: token.from + 1, insert: '' });
+            }
+            else {
+                changes.push({ from: token.from, to: token.from + 1, insert: expected });
+                stack.pop();
+                stackCloserCounts.set(expected, sameCloserDepth - 1);
+            }
+        }
+        return changes;
+    }
+    isSameDiagnostic(left, right) {
+        return left.from === right.from && left.to === right.to && left.message === right.message;
+    }
+    appendDiagnostics(diagnostics) {
+        for (const diagnostic of diagnostics) {
+            const { group: _group, repair: _repair, ...codeMirrorDiagnostic } = diagnostic;
+            this.diagnostics.push(codeMirrorDiagnostic);
+        }
+    }
+    mapRepairedPosition(position, insertAt, insertedLength) {
+        return position <= insertAt ? position : Math.max(insertAt, position - insertedLength);
+    }
+    mapRepairedPositionAfterInsertions(position, insertAts, insertedLength) {
+        let mapped = position;
+        let priorInsertedLength = 0;
+        for (const insertAt of insertAts) {
+            if (position > insertAt + priorInsertedLength) {
+                mapped -= insertedLength;
+            }
+            priorInsertedLength += insertedLength;
+        }
+        return mapped;
+    }
+    makeDiagnosticAt(from, to, message, group) {
+        return {
+            severity: 'error',
+            source: 'DQL syntax',
+            message,
+            from,
+            to,
+            group,
+        };
+    }
+    nodeText(node) {
+        return this.state.sliceDoc(node.from, node.to);
+    }
+    isAdjacentToComma(node, parent) {
+        const before = this.maskLineComments(this.state.sliceDoc(parent.from, node.from)).trimEnd();
+        const after = this.maskLineComments(this.state.sliceDoc(node.to, parent.to)).trimStart();
+        return before.endsWith(',') || after.startsWith(',') || this.nodeText(node) === ',';
+    }
+    isCommaSequence(text) {
+        return /^,{2,}$/.test(this.maskLineComments(text).replace(/\s/g, ''));
+    }
+    isCommaOnlyList(node) {
+        return /^(?:\(,{2,}\)|\[,{2,}\]|\{,{2,}\})$/.test(this.maskLineComments(this.nodeText(node)).replace(/\s/g, ''));
+    }
+    commaSequenceGroup(node) {
+        return `${node.name}:${node.from}:${node.to}:comma-sequence`;
+    }
+    describeConsecutiveCommaError(node, parent) {
+        const contexts = {
+            Projection: 'projection item',
+            FunctionCallBody: 'function argument',
+            EvalCallBody: 'function argument',
+            OuterFunctionCallBody: 'function argument',
+            RawOuterFunctionCallBody: 'function argument',
+            RequiredNumberOuterFunctionCallBody: 'function argument',
+            OptionalNumberOuterFunctionCallBody: 'function argument',
+            FillOuterFunctionCallBody: 'function argument',
+            VariadicOuterFunctionCallBody: 'function argument',
+            RollupFunctionCallBody: 'function argument',
+            CaseFunctionCallBody: 'function argument',
+            InValue: 'argument value',
+            InFieldValue: 'filter value',
+            IndexExpr: 'namespace index',
+            ByListExpr: 'grouping field',
+            FilterClause: 'filter expression',
+        };
+        let context = parent;
+        while (context && !contexts[context.name]) {
+            if (commaContextBoundaries.has(context.name))
+                return null;
+            context = context.parent;
+        }
+        if (!context)
+            return null;
+        const masked = this.maskStringsAndLineComments(this.nodeText(context));
+        const commaRun = /(?:,\s*){2,}/g;
+        let match = commaRun.exec(masked);
+        while (match) {
+            const lastCommaOffset = match.index + match[0].lastIndexOf(',');
+            const runFrom = context.from + match.index;
+            const runTo = context.from + lastCommaOffset + 1;
+            const recoveredCase = context.name === 'Projection' ? this.findCaseExprEndingAt(context, runFrom) : null;
+            if (recoveredCase && this.containsError(recoveredCase) && node.from <= runTo && node.to >= runFrom) {
+                return this.makeDiagnosticAt(runFrom, runFrom, 'CASE result expected after "THEN"', 'CaseResult:' + recoveredCase.from + ':' + recoveredCase.to);
+            }
+            const overlapsRun = node.from === node.to
+                ? (node.from > runFrom || !this.hasMissingValueBeforeComma(node)) && node.from <= runTo
+                : node.from < runTo && node.to > runFrom;
+            if (overlapsRun) {
+                const before = masked
+                    .slice(0, match.index)
+                    .replace(/\s/g, '')
+                    .replace(/^[([{]/, '');
+                const message = before ? `${contexts[context.name]} expected after ","` : `${contexts[context.name]} expected between commas`;
+                return this.makeDiagnosticAt(node.from, node.to, message, `${context.name}:${context.from}:${runFrom}:${runTo}:comma-sequence`);
+            }
+            match = commaRun.exec(masked);
+        }
+        return null;
+    }
+    hasMissingValueBeforeComma(node) {
+        const previous = this.siblingSkippingLineComments(node, 'previous');
+        return Boolean(previous && (this.isOperator(previous) || previous.name === 'Then' || previous.name === 'Else'));
+    }
+    findCaseExprEndingAt(node, position) {
+        let child = node.firstChild;
+        while (child) {
+            if (child.name === 'CaseExpr' && child.to === position)
+                return child;
+            const nested = this.findCaseExprEndingAt(child, position);
+            if (nested)
+                return nested;
+            child = child.nextSibling;
+        }
+        return null;
+    }
+    siblingSkippingLineComments(node, direction) {
+        let sibling = direction === 'previous' ? node.prevSibling : node.nextSibling;
+        while ((sibling === null || sibling === void 0 ? void 0 : sibling.name) === 'LineComment') {
+            sibling = direction === 'previous' ? sibling.prevSibling : sibling.nextSibling;
+        }
+        return sibling;
+    }
+    hasErroredSibling(node) {
+        let sibling = node.prevSibling;
+        while (sibling) {
+            if (sibling.type.isError || this.containsError(sibling)) {
+                return true;
+            }
+            sibling = sibling.prevSibling;
+        }
+        sibling = node.nextSibling;
+        while (sibling) {
+            if (sibling.type.isError || this.containsError(sibling)) {
+                return true;
+            }
+            sibling = sibling.nextSibling;
+        }
+        return false;
+    }
+    maskLineComments(text) {
+        let masked = '';
+        let quote = '';
+        let escaped = false;
+        let inComment = false;
+        for (let index = 0; index < text.length; index += 1) {
+            const char = text[index];
+            if (inComment) {
+                if (char === '\n') {
+                    inComment = false;
+                    masked += char;
+                }
+                else {
+                    masked += ' ';
+                }
+                continue;
+            }
+            if (quote) {
+                masked += char;
+                if (escaped) {
+                    escaped = false;
+                }
+                else if (char === '\\' && quote !== '`') {
+                    escaped = true;
+                }
+                else if (char === quote) {
+                    quote = '';
+                }
+                else if (char === '\n' && quote !== '`') {
+                    quote = '';
+                }
+                continue;
+            }
+            if (char === '"' || char === "'" || char === '`') {
+                quote = char;
+                masked += char;
+            }
+            else if (char === '#') {
+                inComment = true;
+                masked += ' ';
+            }
+            else {
+                masked += char;
+            }
+        }
+        return masked;
+    }
+    maskStringsAndLineComments(text) {
+        let masked = '';
+        let quote = '';
+        let escaped = false;
+        let inComment = false;
+        for (let index = 0; index < text.length; index += 1) {
+            const char = text[index];
+            if (inComment) {
+                if (char === '\n') {
+                    inComment = false;
+                    masked += char;
+                }
+                else {
+                    masked += ' ';
+                }
+                continue;
+            }
+            if (quote) {
+                masked += char === '\n' ? char : ' ';
+                if (escaped) {
+                    escaped = false;
+                }
+                else if (char === '\\' && quote !== '`') {
+                    escaped = true;
+                }
+                else if (char === quote) {
+                    quote = '';
+                }
+                else if (char === '\n' && quote !== '`') {
+                    quote = '';
+                }
+                continue;
+            }
+            if (char === '"' || char === "'" || char === '`') {
+                quote = char;
+                masked += 'x';
+            }
+            else if (char === '#') {
+                inComment = true;
+                masked += ' ';
+            }
+            else {
+                masked += char;
+            }
+        }
+        return masked;
+    }
+    containsError(node) {
+        let child = node.firstChild;
+        while (child) {
+            if (child.type.isError || this.containsError(child)) {
+                return true;
+            }
+            child = child.nextSibling;
+        }
+        return false;
+    }
+    looksLikeProjectionAfterMissingColon(node) {
+        const querySource = node.getChild('QuerySource');
+        return Boolean(querySource && this.containsError(querySource) && !this.containsNode(querySource, 'DColon'));
+    }
+    containsNode(node, name) {
+        let child = node.firstChild;
+        while (child) {
+            if (child.name === name || this.containsNode(child, name)) {
+                return true;
+            }
+            child = child.nextSibling;
+        }
+        return false;
+    }
+    findAncestor(node, name) {
+        let current = node;
+        while (current) {
+            if (current.name === name) {
+                return current;
+            }
+            current = current.parent;
+        }
+        return null;
+    }
+    caseGroup(node) {
+        let current = node;
+        while (current && current.name !== 'CaseWhenClause' && current.name !== 'CaseElseClause' && current.name !== 'CaseExpr') {
+            current = current.parent;
+        }
+        return current ? `${current.name}:${current.from}:${current.to}` : `Case:${node.from}:${node.to}`;
+    }
+    findCaseResultDiagnostics() {
+        if (this.caseResultDiagnostics)
+            return this.caseResultDiagnostics;
+        const diagnostics = [];
+        const seen = new Set();
+        const cursor = this.tree.cursor();
+        while (cursor.next()) {
+            if (cursor.name !== 'CaseExpr')
+                continue;
+            let clause = cursor.node.firstChild;
+            while (clause) {
+                const isWhenClause = clause.name === 'CaseWhenClause';
+                const isElseClause = clause.name === 'CaseElseClause';
+                const recovery = this.siblingSkippingLineComments(clause, 'next');
+                if ((isWhenClause || isElseClause) && (recovery === null || recovery === void 0 ? void 0 : recovery.type.isError)) {
+                    const clauseText = this.maskStringsAndLineComments(this.nodeText(clause));
+                    const match = isWhenClause ? /\bthen\s+(else|end)\b/i.exec(clauseText) : /\belse\s+(end)\b/i.exec(clauseText);
+                    if (match) {
+                        const marker = match[1];
+                        if (marker.toLowerCase() === 'end' && recovery.from !== recovery.to) {
+                            clause = clause.nextSibling;
+                            continue;
+                        }
+                        const markerOffset = match.index + match[0].toLowerCase().lastIndexOf(marker.toLowerCase());
+                        const from = clause.from + markerOffset;
+                        const message = isWhenClause ? 'CASE result expected after "THEN"' : 'CASE result expected after "ELSE"';
+                        const key = `${from}:${message}`;
+                        if (!seen.has(key)) {
+                            diagnostics.push(this.makeDiagnosticAt(from, from + marker.length, message, `CaseResult:${from}`));
+                            seen.add(key);
+                        }
+                        this.caseResultRecoveryErrors.add(this.nodeRangeKey(recovery));
+                    }
+                }
+                clause = clause.nextSibling;
+            }
+        }
+        this.caseResultDiagnostics = diagnostics;
+        return diagnostics;
+    }
+    nodeRangeKey(node) {
+        return `${node.from}:${node.to}`;
+    }
+    isOperator(node) {
+        return [
+            'Pow',
+            'Mul',
+            'Div',
+            'Mod',
+            'Add',
+            'Sub',
+            'Eql',
+            'EqlSingle',
+            'Neq',
+            'Lte',
+            'Lss',
+            'Gte',
+            'Gtr',
+            'EqlRegex',
+            'NeqRegex',
+            'In',
+            'NotInSeq',
+            'And',
+            'Or',
+            'DAnd',
+            'DOr',
+        ].includes(node.name);
+    }
+    getDelimiterIssue() {
+        if (this.delimiterIssue === undefined) {
+            this.delimiterIssue = this.findDelimiterIssue(this.tree.topNode.to);
+        }
+        return this.delimiterIssue;
+    }
+    makeDelimiterDiagnostic(issue) {
+        if (issue.kind === 'quote' || issue.kind === 'quotedQuery') {
+            const context = issue.kind === 'quote' ? 'string literal' : 'quoted query';
+            const message = issue.kind === 'quote' && issue.newline
+                ? 'unescaped newline in string literal'
+                : `unterminated ${context}; expected closing ${this.quoteName(issue.quote)}`;
+            return this.makeDiagnosticAt(issue.from, issue.from + 1, message, `delimiter:${issue.from}`);
+        }
+        if (issue.kind === 'mismatched') {
+            const message = issue.context
+                ? `expected ${this.quoteName(issue.close)} instead of ${this.quoteName(issue.actual)} to close ${issue.context}`
+                : issue.recovery === 'delete'
+                    ? `unexpected closing delimiter "${issue.actual}" before "${issue.close}"`
+                    : `expected "${issue.close}" instead of "${issue.actual}" to close "${issue.open}"`;
+            return this.makeDiagnosticAt(issue.actualFrom, issue.actualFrom + 1, message, `delimiter:${issue.from}`);
+        }
+        if (issue.kind === 'unexpectedClosing') {
+            return this.makeDiagnosticAt(issue.actualFrom, issue.actualFrom + 1, `unexpected closing delimiter "${issue.actual}"`, `delimiter:${issue.actualFrom}`);
+        }
+        return this.makeDiagnosticAt(issue.at, issue.at, `expected "${issue.close}" to close "${issue.open}"`, `delimiter:${issue.from}`);
+    }
+    isRelatedDelimiterError(node, issue) {
+        if (issue.kind === 'quote' || issue.kind === 'quotedQuery') {
+            if (node.from !== node.to) {
+                return node.from < issue.end && node.to > issue.from;
+            }
+            const includesEnd = issue.kind === 'quotedQuery' || !issue.newline;
+            return node.from >= issue.from && (node.from < issue.end || (includesEnd && node.from === issue.end));
+        }
+        return node.from === issue.actualFrom || (node.from <= issue.actualFrom && node.to > issue.actualFrom) || node.from === this.tree.topNode.to;
+    }
+    quoteName(quote) {
+        return quote === '"' ? 'double quote' : quote === "'" ? 'single quote' : 'backtick';
+    }
+    findQuotedQueryDelimiterInfo() {
+        var _a;
+        if (this.quotedQueryDelimiterInfo)
+            return this.quotedQueryDelimiterInfo;
+        const transparent = new Set();
+        const issues = new Map();
+        const fallbackRanges = [];
+        const fallbackDiagnostics = [];
+        const addFallbackRange = (range) => {
+            if (range && !fallbackRanges.some((existing) => existing.from === range.from && existing.to === range.to)) {
+                fallbackRanges.push(range);
+            }
+        };
+        let pending = null;
+        const cursor = this.tree.cursor();
+        while (cursor.next()) {
+            if (Date.now() >= this.deadline)
+                break;
+            if (cursor.name === 'StringLiteral') {
+                addFallbackRange(this.findFallbackQuotedQueryRange(cursor.node));
+            }
+            if (cursor.name === 'Queted' && ((_a = cursor.node.parent) === null || _a === void 0 ? void 0 : _a.name) !== 'OuterArgItem') {
+                addFallbackRange(this.findFallbackQuotedQueryRangeFromOpening(cursor.from));
+            }
+            if (cursor.name !== 'OuterArgItem') {
+                continue;
+            }
+            const quoted = [];
+            let child = cursor.node.firstChild;
+            while (child) {
+                if (child.name === 'Queted')
+                    quoted.push(child);
+                child = child.nextSibling;
+            }
+            for (const quote of quoted)
+                transparent.add(quote.from);
+            if (quoted.length >= 2) {
+                const first = quoted[0];
+                const last = quoted[quoted.length - 1];
+                const expected = this.nodeText(first);
+                const actual = this.nodeText(last);
+                if (expected !== actual) {
+                    issues.set(last.from, {
+                        kind: 'mismatched',
+                        open: expected,
+                        close: expected,
+                        from: first.from,
+                        actual,
+                        actualFrom: last.from,
+                        context: 'quoted query',
+                    });
+                }
+                else {
+                    const range = { from: first.from, to: last.to };
+                    const payload = this.state.sliceDoc(first.to, last.from);
+                    if (this.repairScopedDelimiterMismatches(payload) !== null && this.isFallbackQuotedQueryRange(range.from, range.to)) {
+                        addFallbackRange(range);
+                    }
+                }
+            }
+            else if (quoted.length === 1) {
+                const quote = quoted[0];
+                const wrapperQuote = this.nodeText(quote);
+                const lexicalClosing = this.findLexicalQuotedQueryClosing(this.state.doc.toString(), quote.from, wrapperQuote);
+                const fallbackRange = lexicalClosing === null ? null : { from: quote.from, to: lexicalClosing + 1 };
+                if (fallbackRange && this.isFallbackQuotedQueryRange(fallbackRange.from, fallbackRange.to)) {
+                    addFallbackRange(fallbackRange);
+                }
+                else {
+                    const issue = {
+                        kind: 'quotedQuery',
+                        quote: wrapperQuote,
+                        from: quote.from,
+                        end: cursor.to,
+                        repairAt: cursor.to,
+                    };
+                    if (!pending || issue.from < pending.from)
+                        pending = issue;
+                }
+            }
+        }
+        fallbackRanges.sort((left, right) => left.from - right.from || right.to - left.to);
+        const disjointFallbackRanges = [];
+        for (const range of fallbackRanges) {
+            const previous = disjointFallbackRanges[disjointFallbackRanges.length - 1];
+            if (!previous || range.from >= previous.to)
+                disjointFallbackRanges.push(range);
+        }
+        fallbackRanges.splice(0, fallbackRanges.length, ...disjointFallbackRanges);
+        for (const range of fallbackRanges) {
+            transparent.add(range.from);
+            transparent.add(range.to - 1);
+        }
+        fallbackDiagnostics.push(...this.diagnoseFallbackQuotedQueries(fallbackRanges));
+        this.quotedQueryDelimiterInfo = { transparent, issues, pending, fallbackRanges, fallbackDiagnostics };
+        return this.quotedQueryDelimiterInfo;
+    }
+    findFallbackQuotedQueryRange(node) {
+        var _a;
+        const indexItem = node.parent;
+        const indexExpr = indexItem === null || indexItem === void 0 ? void 0 : indexItem.parent;
+        const namespace = indexExpr === null || indexExpr === void 0 ? void 0 : indexExpr.parent;
+        if ((indexItem === null || indexItem === void 0 ? void 0 : indexItem.name) !== 'IndexItem' || (indexExpr === null || indexExpr === void 0 ? void 0 : indexExpr.name) !== 'IndexExpr' || (namespace === null || namespace === void 0 ? void 0 : namespace.name) !== 'Namespace') {
+            return null;
+        }
+        if (indexItem.prevSibling)
+            return null;
+        const namespaceParent = namespace.parent;
+        if ((namespaceParent === null || namespaceParent === void 0 ? void 0 : namespaceParent.name) !== 'QueryExpr' && (namespaceParent === null || namespaceParent === void 0 ? void 0 : namespaceParent.name) !== 'Query')
+            return null;
+        if (namespaceParent.name === 'Query' && ((_a = this.siblingSkippingLineComments(namespace, 'next')) === null || _a === void 0 ? void 0 : _a.name) === 'DColon')
+            return null;
+        const raw = this.nodeText(node);
+        const quote = raw[0];
+        if (!['"', "'", '`'].includes(quote))
+            return null;
+        const text = this.state.doc.toString();
+        const lexicalClosing = this.findLexicalQuotedQueryClosing(text, node.from, quote);
+        const candidates = [lexicalClosing === null ? null : lexicalClosing + 1, raw.length >= 2 && raw[raw.length - 1] === quote ? node.to : null];
+        for (const to of [...new Set(candidates)]) {
+            if (to === null || to <= node.from + 1 || this.state.sliceDoc(to - 1, to) !== quote)
+                continue;
+            if (this.isFallbackQuotedQueryRange(node.from, to))
+                return { from: node.from, to };
+        }
+        return null;
+    }
+    findFallbackQuotedQueryRangeFromOpening(from) {
+        const quote = this.state.sliceDoc(from, from + 1);
+        if (!['"', "'", '`'].includes(quote))
+            return null;
+        const closing = this.findLexicalQuotedQueryClosing(this.state.doc.toString(), from, quote);
+        if (closing === null || closing <= from)
+            return null;
+        const to = closing + 1;
+        return this.isFallbackQuotedQueryRange(from, to) ? { from, to } : null;
+    }
+    isFallbackQuotedQueryRange(from, to) {
+        const originalPayload = this.state.sliceDoc(from + 1, to - 1);
+        if (!this.formsOuterQuotedQuery(from, to, 'M::cpu:(usage)'))
+            return false;
+        if (this.isQueryPayload(originalPayload))
+            return true;
+        const bulkRepairedPayload = this.repairScopedDelimiterMismatches(originalPayload);
+        if (bulkRepairedPayload && this.isQueryPayload(bulkRepairedPayload))
+            return true;
+        const queue = [{ payload: originalPayload, depth: 0 }];
+        const seen = new Set();
+        while (queue.length > 0 && Date.now() < this.deadline) {
+            const candidate = queue.shift();
+            if (seen.has(candidate.payload))
+                continue;
+            seen.add(candidate.payload);
+            const issue = this.findFirstDelimiterMismatch(candidate.payload);
+            if (!issue) {
+                if (candidate.depth > 0 && this.isQueryPayload(candidate.payload))
+                    return true;
+                continue;
+            }
+            if (candidate.depth >= maxMismatchRepairDepth + 1)
+                continue;
+            queue.push({
+                payload: candidate.payload.slice(0, issue.from) + candidate.payload.slice(issue.from + 1),
+                depth: candidate.depth + 1,
+            });
+            if (issue.expected) {
+                queue.push({
+                    payload: candidate.payload.slice(0, issue.from) + issue.expected + candidate.payload.slice(issue.from + 1),
+                    depth: candidate.depth + 1,
+                });
+            }
+        }
+        return false;
+    }
+    isQueryPayload(payload) {
+        var _a;
+        const payloadState = this.state.update({ changes: { from: 0, to: this.state.doc.length, insert: payload }, filter: false }).state;
+        const payloadTree = this.getCompleteTree(payloadState);
+        if (!payloadTree)
+            return false;
+        const cursor = payloadTree.cursor();
+        while (cursor.next()) {
+            if (cursor.name !== 'Query' || ((_a = cursor.node.parent) === null || _a === void 0 ? void 0 : _a.name) !== 'QueryExpr')
+                continue;
+            return !this.containsError(cursor.node) || Boolean(cursor.node.getChild('QueryClause'));
+        }
+        return false;
+    }
+    diagnoseFallbackQuotedQueries(ranges) {
+        if (ranges.length === 0)
+            return [];
+        const diagnostics = [];
+        const canonicalPayload = 'M::cpu:(usage)';
+        for (const range of ranges) {
+            if (Date.now() >= this.deadline)
+                return diagnostics;
+            const payload = this.state.sliceDoc(range.from + 1, range.to - 1);
+            const payloadState = this.state.update({ changes: { from: 0, to: this.state.doc.length, insert: payload }, filter: false }).state;
+            const payloadParser = new Parser(payloadState, this.deadline);
+            payloadParser.repairDepth = this.repairDepth;
+            payloadParser.mismatchRepairDepth = this.mismatchRepairDepth;
+            payloadParser.terminalRepairUsed = this.terminalRepairUsed;
+            payloadParser.analyze();
+            for (const diagnostic of payloadParser.getDiagnostics()) {
+                const mapped = {
+                    ...diagnostic,
+                    from: diagnostic.from + range.from + 1,
+                    to: diagnostic.to + range.from + 1,
+                };
+                if (!diagnostics.some((existing) => this.isSameDiagnostic(existing, mapped)))
+                    diagnostics.push(mapped);
+            }
+        }
+        if (Date.now() >= this.deadline)
+            return diagnostics;
+        const changes = ranges.map((range) => ({ from: range.from + 1, to: range.to - 1, insert: canonicalPayload }));
+        const probeTransaction = this.state.update({ changes, filter: false });
+        const insertedRanges = [];
+        let offset = 0;
+        for (const range of ranges) {
+            const from = range.from + 1 + offset;
+            insertedRanges.push({ from, to: from + canonicalPayload.length });
+            offset += canonicalPayload.length - (range.to - range.from - 2);
+        }
+        const probeParser = new Parser(probeTransaction.state, this.deadline);
+        probeParser.repairDepth = this.repairDepth;
+        probeParser.mismatchRepairDepth = this.mismatchRepairDepth;
+        probeParser.terminalRepairUsed = this.terminalRepairUsed;
+        probeParser.analyze();
+        const outerDiagnostics = probeParser.getDiagnostics().filter((diagnostic) => !insertedRanges.some((range) => diagnostic.from === diagnostic.to
+            ? diagnostic.from >= range.from && diagnostic.from <= range.to
+            : diagnostic.from < range.to && diagnostic.to > range.from));
+        for (const diagnostic of this.mapDiagnosticsThroughChanges(outerDiagnostics, probeTransaction.changes)) {
+            if (!diagnostics.some((existing) => this.isSameDiagnostic(existing, diagnostic)))
+                diagnostics.push(diagnostic);
+        }
+        return diagnostics;
+    }
+    repairScopedDelimiterMismatches(text) {
+        var _a, _b, _c;
+        const pairs = { '(': ')', '[': ']', '{': '}' };
+        const closers = new Set(Object.values(pairs));
+        const stack = [];
+        const stackCloserCounts = new Map();
+        const futureCloserCounts = new Map();
+        const changes = [];
+        const transparent = new Set();
+        let quote = '';
+        let escaped = false;
+        let inComment = false;
+        for (let index = 0; index < text.length; index += 1) {
+            if (Date.now() >= this.deadline)
+                return null;
+            const char = text[index];
+            if (inComment) {
+                if (char === '\n')
+                    inComment = false;
+                continue;
+            }
+            if (quote) {
+                if (escaped) {
+                    escaped = false;
+                }
+                else if (char === '\\' && quote.charCodeAt(0) !== 96) {
+                    escaped = true;
+                }
+                else if (char === quote) {
+                    quote = '';
+                }
+                continue;
+            }
+            if (char === '"' || char === "'" || char.charCodeAt(0) === 96) {
+                quote = char;
+            }
+            else if (char === '#') {
+                inComment = true;
+            }
+            else if (pairs[char]) {
+                const closer = pairs[char];
+                stack.push(closer);
+                stackCloserCounts.set(closer, ((_a = stackCloserCounts.get(closer)) !== null && _a !== void 0 ? _a : 0) + 1);
+                futureCloserCounts.clear();
+            }
+            else if (closers.has(char)) {
+                const expected = stack[stack.length - 1];
+                if (char === expected) {
+                    stack.pop();
+                    stackCloserCounts.set(expected, ((_b = stackCloserCounts.get(expected)) !== null && _b !== void 0 ? _b : 1) - 1);
+                    futureCloserCounts.clear();
+                    continue;
+                }
+                if (!expected) {
+                    changes.push({ from: index, to: index + 1, insert: '' });
+                    continue;
+                }
+                const sameCloserDepth = (_c = stackCloserCounts.get(expected)) !== null && _c !== void 0 ? _c : 0;
+                let futureCloserCount = futureCloserCounts.get(expected);
+                if (futureCloserCount === undefined) {
+                    const countedClosers = this.countFutureClosersAtCurrentDepth(text, index + 1, expected, transparent);
+                    if (countedClosers === null)
+                        return null;
+                    futureCloserCount = countedClosers;
+                    futureCloserCounts.set(expected, countedClosers);
+                }
+                if (futureCloserCount >= sameCloserDepth) {
+                    changes.push({ from: index, to: index + 1, insert: '' });
+                }
+                else {
+                    changes.push({ from: index, to: index + 1, insert: expected });
+                    stack.pop();
+                    stackCloserCounts.set(expected, sameCloserDepth - 1);
+                }
+            }
+        }
+        if (quote)
+            return null;
+        const missingClosers = [...stack].reverse().join('');
+        if (changes.length === 0 && !missingClosers)
+            return null;
+        let repaired = '';
+        let copiedTo = 0;
+        for (const change of changes) {
+            repaired += text.slice(copiedTo, change.from) + change.insert;
+            copiedTo = change.to;
+        }
+        return repaired + text.slice(copiedTo) + missingClosers;
+    }
+    findFirstDelimiterMismatch(text) {
+        const pairs = { '(': ')', '[': ']', '{': '}' };
+        const closers = new Set(Object.values(pairs));
+        const stack = [];
+        let quote = '';
+        let escaped = false;
+        let inComment = false;
+        for (let index = 0; index < text.length; index += 1) {
+            const char = text[index];
+            if (inComment) {
+                if (char === '\n')
+                    inComment = false;
+                continue;
+            }
+            if (quote) {
+                if (escaped) {
+                    escaped = false;
+                }
+                else if (char === '\\' && quote.charCodeAt(0) !== 96) {
+                    escaped = true;
+                }
+                else if (char === quote) {
+                    quote = '';
+                }
+                continue;
+            }
+            if (char === '"' || char === "'" || char.charCodeAt(0) === 96) {
+                quote = char;
+            }
+            else if (char === '#') {
+                inComment = true;
+            }
+            else if (pairs[char]) {
+                stack.push(pairs[char]);
+            }
+            else if (closers.has(char)) {
+                const expected = stack[stack.length - 1];
+                if (char !== expected)
+                    return { from: index, expected };
+                stack.pop();
+            }
+        }
+        return null;
+    }
+    formsOuterQuotedQuery(from, to, payload) {
+        const repairedState = this.state.update({ changes: { from: from + 1, to: to - 1, insert: payload }, filter: false }).state;
+        const repairedTree = this.getCompleteTree(repairedState);
+        if (!repairedTree)
+            return false;
+        const wrapperQuote = this.state.sliceDoc(from, from + 1);
+        const expectedClosing = from + payload.length + 1;
+        const cursor = repairedTree.cursor();
+        while (cursor.next()) {
+            if (cursor.name !== 'OuterArgItem' || cursor.from !== from)
+                continue;
+            const query = cursor.node.getChild('Query');
+            const quotes = cursor.node.getChildren('Queted');
+            const openingQuote = quotes.find((quote) => quote.from === from);
+            const closingQuote = quotes.find((quote) => quote.from === expectedClosing);
+            if (query &&
+                openingQuote &&
+                closingQuote &&
+                repairedState.sliceDoc(openingQuote.from, openingQuote.to) === wrapperQuote &&
+                repairedState.sliceDoc(closingQuote.from, closingQuote.to) === wrapperQuote) {
+                return true;
+            }
+        }
+        return false;
+    }
+    findDelimiterIssue(end, scoreRecovery = true) {
+        var _a, _b, _c, _d, _e;
+        const text = this.state.sliceDoc(0, end);
+        const stack = [];
+        const pairs = { '(': ')', '[': ']', '{': '}' };
+        const closingDelimiters = new Set(Object.values(pairs));
+        let quote = '';
+        let quoteFrom = -1;
+        let quoteRepairCandidates = [];
+        let escaped = false;
+        const quotedQueryDelimiters = this.findQuotedQueryDelimiterInfo();
+        let quotedQueryOuterDepth = -1;
+        for (let index = 0; index < text.length; index += 1) {
+            if ((index & 255) === 0 && Date.now() >= this.deadline)
+                return null;
+            const char = text[index];
+            const fallbackRange = quotedQueryDelimiters.fallbackRanges.find((range) => index >= range.from && index < range.to);
+            if (fallbackRange) {
+                index = fallbackRange.to - 1;
+                continue;
+            }
+            const quotedQueryIssue = quotedQueryDelimiters.issues.get(index);
+            if (quotedQueryIssue)
+                return quotedQueryIssue;
+            if (quotedQueryDelimiters.transparent.has(index)) {
+                if (((_a = quotedQueryDelimiters.pending) === null || _a === void 0 ? void 0 : _a.kind) === 'quotedQuery' && quotedQueryDelimiters.pending.from === index) {
+                    quotedQueryOuterDepth = stack.length;
+                }
+                continue;
+            }
+            if (quote) {
+                if (escaped) {
+                    escaped = false;
+                }
+                else if (char === '\\' && quote !== '`') {
+                    escaped = true;
+                }
+                else if (char === quote) {
+                    quote = '';
+                    quoteFrom = -1;
+                    quoteRepairCandidates = [];
+                }
+                else if (char === '\n' && quote !== '`') {
+                    const quotedQueryRepairAt = this.findVerifiedQuotedQueryRepairAt(text, quoteFrom, quote, (_b = stack[stack.length - 1]) === null || _b === void 0 ? void 0 : _b.close, end);
+                    if (quotedQueryRepairAt !== null) {
+                        return {
+                            kind: 'quotedQuery',
+                            quote,
+                            from: quoteFrom,
+                            end,
+                            repairAt: quotedQueryRepairAt,
+                        };
+                    }
+                    const recovery = this.findStringNewlineRecovery(text, quoteFrom + 1, quote);
+                    return {
+                        kind: 'quote',
+                        quote,
+                        from: quoteFrom,
+                        end: (_c = recovery === null || recovery === void 0 ? void 0 : recovery.end) !== null && _c !== void 0 ? _c : index + 1,
+                        newline: true,
+                        repairLineBreaks: recovery === null || recovery === void 0 ? void 0 : recovery.lineBreaks,
+                    };
+                }
+                else if (stack.length > 0 && char === stack[stack.length - 1].close) {
+                    quoteRepairCandidates.push(index);
+                }
+                continue;
+            }
+            if (char === '"' || char === "'" || char === '`') {
+                quote = char;
+                quoteFrom = index;
+                quoteRepairCandidates = [];
+                continue;
+            }
+            if (char === '#') {
+                while (index + 1 < text.length && text[index + 1] !== '\n') {
+                    index += 1;
+                }
+                continue;
+            }
+            if (pairs[char]) {
+                stack.push({ open: char, close: pairs[char], from: index });
+                continue;
+            }
+            const last = stack[stack.length - 1];
+            if (last && char === last.close) {
+                if (((_d = quotedQueryDelimiters.pending) === null || _d === void 0 ? void 0 : _d.kind) === 'quotedQuery' &&
+                    quotedQueryOuterDepth > 0 &&
+                    stack.length === quotedQueryOuterDepth &&
+                    quotedQueryDelimiters.pending.repairAt === quotedQueryDelimiters.pending.end) {
+                    quotedQueryDelimiters.pending.repairAt = index;
+                    quotedQueryOuterDepth = -1;
+                }
+                stack.pop();
+            }
+            else if (last && closingDelimiters.has(char)) {
+                const sameCloserDepth = stack.filter((entry) => entry.close === last.close).length;
+                const futureCloserCount = scoreRecovery
+                    ? this.countFutureClosersAtCurrentDepth(text, index + 1, last.close, quotedQueryDelimiters.transparent)
+                    : 0;
+                return {
+                    kind: 'mismatched',
+                    open: last.open,
+                    close: last.close,
+                    from: last.from,
+                    actual: char,
+                    actualFrom: index,
+                    recovery: scoreRecovery
+                        ? futureCloserCount !== null && futureCloserCount >= sameCloserDepth
+                            ? 'delete'
+                            : Date.now() >= this.deadline
+                                ? 'replace'
+                                : this.chooseMismatchRecovery(index, index + 1, last.close)
+                        : 'replace',
+                };
+            }
+            else if (!last && closingDelimiters.has(char) && !this.hasPrecedingErrorEndingAt(index)) {
+                return { kind: 'unexpectedClosing', actual: char, actualFrom: index };
+            }
+        }
+        if (quote) {
+            return {
+                kind: 'quote',
+                quote,
+                from: quoteFrom,
+                end,
+                repairAt: this.chooseQuoteRepairAt(text, quoteFrom, quote, (_e = stack[stack.length - 1]) === null || _e === void 0 ? void 0 : _e.close, quoteRepairCandidates, end),
+            };
+        }
+        if (quotedQueryDelimiters.pending)
+            return quotedQueryDelimiters.pending;
+        const unclosed = stack[stack.length - 1];
+        return unclosed ? { kind: 'unclosed', ...unclosed, at: end } : null;
+    }
+    hasPrecedingErrorEndingAt(position) {
+        const cursor = this.tree.cursor();
+        while (cursor.next()) {
+            if (cursor.type.isError && cursor.from < position && cursor.to === position)
+                return true;
+        }
+        return false;
+    }
+    countFutureClosersAtCurrentDepth(text, start, closer, transparent) {
+        const pairs = { '(': ')', '[': ']', '{': '}' };
+        const closingDelimiters = new Set(Object.values(pairs));
+        const nestedClosers = [];
+        let quote = '';
+        let escaped = false;
+        let inComment = false;
+        let count = 0;
+        for (let index = start; index < text.length; index += 1) {
+            if (Date.now() >= this.deadline)
+                return null;
+            const char = text[index];
+            if (transparent.has(index))
+                continue;
+            if (inComment) {
+                if (char === '\n')
+                    inComment = false;
+                continue;
+            }
+            if (quote) {
+                if (escaped) {
+                    escaped = false;
+                }
+                else if (char === '\\' && quote.charCodeAt(0) !== 96) {
+                    escaped = true;
+                }
+                else if (char === quote) {
+                    quote = '';
+                }
+                else if (char === '\n' && quote.charCodeAt(0) !== 96) {
+                    quote = '';
+                }
+                continue;
+            }
+            if (char === '"' || char === "'" || char.charCodeAt(0) === 96) {
+                quote = char;
+            }
+            else if (char === '#') {
+                inComment = true;
+            }
+            else if (pairs[char]) {
+                nestedClosers.push(pairs[char]);
+            }
+            else if (closingDelimiters.has(char)) {
+                if (nestedClosers.length > 0) {
+                    nestedClosers.pop();
+                }
+                else if (char === closer) {
+                    count += 1;
+                }
+            }
+        }
+        return count;
+    }
+    chooseQuoteRepairAt(text, quoteFrom, quote, expectedCloser, closerCandidates, end) {
+        var _a;
+        const quotedQueryRepairAt = this.findVerifiedQuotedQueryRepairAt(text, quoteFrom, quote, expectedCloser, end);
+        if (quotedQueryRepairAt !== null)
+            return quotedQueryRepairAt;
+        const ordinaryPositions = closerCandidates.length > 0 ? [...new Set(closerCandidates)].sort((left, right) => left - right) : [end];
+        const repairs = [];
+        for (let index = 0; index < ordinaryPositions.length && Date.now() < this.deadline; index += 1) {
+            const repair = this.scoreQuoteRepairCandidate(ordinaryPositions[index], quote, quoteFrom);
+            repairs.push(repair);
+            const localEnd = ((_a = ordinaryPositions[index + 1]) !== null && _a !== void 0 ? _a : ordinaryPositions[index]) + quote.length;
+            if (repair.complete && !repair.errorPositions.some(({ from, to }) => from <= localEnd && to >= quoteFrom)) {
+                return repair.insertAt;
+            }
+        }
+        if (repairs.length < ordinaryPositions.length)
+            return undefined;
+        if (!repairs.some(({ complete }) => complete))
+            return end;
+        return this.pickQuoteRepair(repairs, end);
+    }
+    findVerifiedQuotedQueryRepairAt(text, quoteFrom, quote, expectedCloser, end) {
+        const candidate = expectedCloser ? this.findQuotedQueryRepairCandidate(text, quoteFrom + 1, quote, expectedCloser) : null;
+        const positions = [...new Set([candidate, end].filter((position) => position !== null))];
+        const repairs = positions.map((insertAt) => this.scoreQuoteRepairCandidate(insertAt, quote, quoteFrom)).filter((repair) => repair.quotedQuery);
+        return repairs.length > 0 ? this.pickQuoteRepair(repairs, end) : null;
+    }
+    scoreQuoteRepairCandidate(insertAt, quote, quoteFrom) {
+        if (Date.now() >= this.deadline) {
+            return { insertAt, errors: Number.POSITIVE_INFINITY, errorPositions: [], quotedQuery: false, complete: false };
+        }
+        const state = this.state.update({ changes: { from: insertAt, insert: quote }, filter: false }).state;
+        const tree = this.getCompleteTree(state);
+        if (!tree) {
+            return { insertAt, errors: Number.POSITIVE_INFINITY, errorPositions: [], quotedQuery: false, complete: false };
+        }
+        const cursor = tree.cursor();
+        let errors = 0;
+        const errorPositions = [];
+        let quotedQuery = false;
+        while (cursor.next()) {
+            if (cursor.type.isError) {
+                errors += 1;
+                errorPositions.push({ from: cursor.from, to: cursor.to });
+            }
+            if (cursor.name !== 'OuterArgItem')
+                continue;
+            const quoted = [];
+            let child = cursor.node.firstChild;
+            while (child) {
+                if (child.name === 'Queted')
+                    quoted.push(child);
+                child = child.nextSibling;
+            }
+            if (quoted.length >= 2 && quoted[0].from === quoteFrom && quoted.some((node) => node.from === insertAt)) {
+                quotedQuery = true;
+            }
+        }
+        return { insertAt, errors, errorPositions, quotedQuery, complete: true };
+    }
+    pickQuoteRepair(candidates, end) {
+        return candidates.sort((left, right) => {
+            if (left.errors !== right.errors)
+                return left.errors - right.errors;
+            const leftAtEnd = left.insertAt === end;
+            const rightAtEnd = right.insertAt === end;
+            if (leftAtEnd !== rightAtEnd)
+                return leftAtEnd ? 1 : -1;
+            return right.insertAt - left.insertAt;
+        })[0].insertAt;
+    }
+    findQuotedQueryRepairCandidate(text, start, outerQuote, expectedCloser) {
+        const pairs = { '(': ')', '[': ']', '{': '}' };
+        const closingDelimiters = new Set(Object.values(pairs));
+        const stack = [];
+        let quote = '';
+        let escaped = false;
+        let outerEscaped = false;
+        let inComment = false;
+        for (let index = start; index < text.length; index += 1) {
+            const char = text[index];
+            if (inComment) {
+                if (char === '\n')
+                    inComment = false;
+                continue;
+            }
+            if (quote) {
+                if (escaped) {
+                    escaped = false;
+                }
+                else if (char === '\\' && quote.charCodeAt(0) !== 96) {
+                    escaped = true;
+                }
+                else if (char === quote) {
+                    quote = '';
+                }
+                continue;
+            }
+            if (outerEscaped) {
+                outerEscaped = false;
+                continue;
+            }
+            if (char === '\\' && outerQuote.charCodeAt(0) !== 96) {
+                outerEscaped = true;
+                continue;
+            }
+            if (char === '"' || char === "'" || char.charCodeAt(0) === 96) {
+                quote = char;
+                continue;
+            }
+            if (char === '#') {
+                inComment = true;
+                continue;
+            }
+            if (pairs[char]) {
+                stack.push(pairs[char]);
+                continue;
+            }
+            if (!closingDelimiters.has(char))
+                continue;
+            if (stack[stack.length - 1] === char) {
+                stack.pop();
+            }
+            else if (stack.length === 0 && char === expectedCloser) {
+                return index;
+            }
+        }
+        return null;
+    }
+    chooseMismatchRecovery(from, to, expectedCloser) {
+        const replacement = this.state.update({ changes: { from, to, insert: expectedCloser }, filter: false }).state;
+        const deletion = this.state.update({ changes: { from, to, insert: '' }, filter: false }).state;
+        const replacementBalanceCost = this.delimiterBalanceCost(replacement.doc.toString());
+        const deletionBalanceCost = this.delimiterBalanceCost(deletion.doc.toString());
+        return deletionBalanceCost < replacementBalanceCost ? 'delete' : 'replace';
+    }
+    delimiterBalanceCost(text) {
+        const pairs = { '(': ')', '[': ']', '{': '}' };
+        const closingDelimiters = new Set(Object.values(pairs));
+        const stack = [];
+        let quote = '';
+        let escaped = false;
+        let inComment = false;
+        let errors = 0;
+        for (let index = 0; index < text.length; index += 1) {
+            if (Date.now() >= this.deadline)
+                return Number.POSITIVE_INFINITY;
+            const char = text[index];
+            if (inComment) {
+                if (char === '\n')
+                    inComment = false;
+                continue;
+            }
+            if (quote) {
+                if (escaped) {
+                    escaped = false;
+                }
+                else if (char === '\\' && quote.charCodeAt(0) !== 96) {
+                    escaped = true;
+                }
+                else if (char === quote) {
+                    quote = '';
+                }
+                else if (char === '\n' && quote.charCodeAt(0) !== 96) {
+                    quote = '';
+                }
+                continue;
+            }
+            if (char === '"' || char === "'" || char.charCodeAt(0) === 96) {
+                quote = char;
+            }
+            else if (char === '#') {
+                inComment = true;
+            }
+            else if (pairs[char]) {
+                stack.push(pairs[char]);
+            }
+            else if (closingDelimiters.has(char)) {
+                if (stack[stack.length - 1] === char) {
+                    stack.pop();
+                }
+                else {
+                    errors += 1;
+                    if (stack.length > 0)
+                        stack.pop();
+                }
+            }
+        }
+        return errors + stack.length + (quote ? 1 : 0);
+    }
+    findStringNewlineRecovery(text, start, quote) {
+        let escaped = false;
+        const lineBreaks = [];
+        for (let index = start; index < text.length; index += 1) {
+            const char = text[index];
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === '\\') {
+                escaped = true;
+            }
+            else if (char === quote) {
+                return { end: index + 1, lineBreaks };
+            }
+            else if (char === '\n') {
+                lineBreaks.push(index);
+            }
+        }
+        return null;
+    }
+    checkAST(node) {
+        if (!node || Date.now() >= this.deadline)
+            return;
+        if (!node.type.isError && !this.containsError(node)) {
+            switch (node.name) {
+                case 'Query':
+                case 'QueryFragment':
+                    this.checkDuplicateQueryClauses(node);
+                    break;
+                case 'ShowExpr':
+                    this.checkDuplicateShowClauses(node);
+                    this.checkShowFunctionRequirements(node);
+                    break;
+                case 'TimeRange':
+                    this.checkTimeRangeShape(node);
+                    break;
+                case 'RollupIdentifier':
+                    this.checkBareRollup(node);
+                    break;
+                case 'RollupFunctionCall':
+                    this.checkRollupFunctionCall(node);
+                    break;
+                case 'FunctionCall':
+                    this.checkFunctionCall(node);
+                    break;
+                case 'OuterFunctionCall':
+                    this.checkOuterFunctionCall(node);
+                    break;
+                case 'TargetClause':
+                    this.checkProjectionAlias(node);
+                    break;
+                case 'LimitClause':
+                case 'OffsetClause':
+                case 'SLimitClause':
+                case 'SOffsetClause':
+                    this.checkIntegerClause(node);
+                    break;
+                case 'FilterSubExpr':
+                    this.checkFilterSubqueryOperator(node);
+                    break;
+                case 'FieldName':
+                    this.checkFieldName(node);
+                    break;
+                case 'CaseFunctionIdentifier':
+                    this.checkCaseFunction(node);
+                    break;
+                case 'CaseExpr':
+                    this.checkCaseResults(node);
+                    break;
+            }
+        }
+        let child = node.firstChild;
+        while (child) {
+            this.checkAST(child);
+            child = child.nextSibling;
+        }
+    }
+    checkDuplicateQueryClauses(query) {
+        const seen = new Set();
+        let child = query.firstChild;
+        while (child) {
+            if (child.name === 'QueryClause' || child.name === 'QueryFragmentClause') {
+                const clause = child.firstChild;
+                if (clause) {
+                    const label = queryClauseLabels.get(clause.name);
+                    if (label) {
+                        if (seen.has(clause.name)) {
+                            this.pushSemanticDiagnostic(clause, `duplicate "${label}" clause`, `duplicate:${query.from}:${clause.name}`);
+                        }
+                        else {
+                            seen.add(clause.name);
+                        }
+                    }
+                }
+            }
+            child = child.nextSibling;
+        }
+    }
+    checkDuplicateShowClauses(show) {
+        const seen = new Set();
+        let child = show.firstChild;
+        while (child) {
+            const label = queryClauseLabels.get(child.name);
+            if (label) {
+                if (seen.has(child.name)) {
+                    this.pushSemanticDiagnostic(child, `duplicate "${label}" clause`, `duplicate:${show.from}:${child.name}`);
+                }
+                else {
+                    seen.add(child.name);
+                }
+            }
+            child = child.nextSibling;
+        }
+    }
+    checkIntegerClause(clause) {
+        const number = clause.getChild('Number');
+        if (!number)
+            return;
+        const value = this.numericValue(number);
+        if (value !== null && Number.isInteger(value) && value >= 0)
+            return;
+        const keyword = numericClauses.get(clause.name);
+        if (keyword)
+            this.pushSemanticDiagnostic(number, `integer expected after "${keyword}"`, `integer:${clause.from}`);
+    }
+    checkTimeRangeShape(range) {
+        var _a;
+        const raw = this.maskLineComments(this.nodeText(range));
+        const segments = this.splitTopLevelSegments(raw, ':');
+        const expressions = [];
+        let child = range.firstChild;
+        while (child) {
+            if (child.name === 'TimeExpr')
+                expressions.push(child);
+            child = child.nextSibling;
+        }
+        if (segments.length > 4) {
+            this.pushSemanticDiagnostic(range, 'time range accepts at most four colon-separated values', `time-shape:${range.from}`);
+            return;
+        }
+        if (segments.every((segment) => raw.slice(segment.from, segment.to).trim().length === 0)) {
+            this.pushSemanticDiagnostic(range, 'time range must contain at least one value', `time-shape:${range.from}`);
+            return;
+        }
+        for (let index = 0; index < segments.length; index += 1) {
+            const segment = segments[index];
+            const absoluteFrom = range.from + segment.from;
+            const absoluteTo = range.from + segment.to;
+            const segmentExpressions = expressions.filter((expression) => expression.from >= absoluteFrom && expression.to <= absoluteTo);
+            const expressionCount = segmentExpressions.length;
+            const hasText = raw.slice(segment.from, segment.to).trim().length > 0;
+            if ((hasText && expressionCount !== 1) || (!hasText && expressionCount !== 0)) {
+                this.pushSemanticDiagnosticAt(absoluteFrom, absoluteTo, 'invalid value in time range', `time-shape:${range.from}`);
+                return;
+            }
+            if (segments.length > 1 && expressionCount === 1) {
+                const kind = (_a = segmentExpressions[0].firstChild) === null || _a === void 0 ? void 0 : _a.name;
+                if (index < 2 && kind !== 'Number' && kind !== 'Duration' && kind !== 'PresetExpr') {
+                    this.pushSemanticDiagnostic(segmentExpressions[0], 'time range boundary must be a timestamp, duration, or preset', `time-shape:${range.from}`);
+                    return;
+                }
+                if (index === 2 && kind !== 'Number' && kind !== 'Duration') {
+                    this.pushSemanticDiagnostic(segmentExpressions[0], 'time range interval must be a number or duration', `time-shape:${range.from}`);
+                    return;
+                }
+                if (index === 3 && kind !== 'RollupIdentifier' && kind !== 'RollupFunctionCall') {
+                    this.pushSemanticDiagnostic(segmentExpressions[0], 'time range rollup must be a supported rollup function', `time-shape:${range.from}`);
+                    return;
+                }
+            }
+        }
+    }
+    checkBareRollup(identifier) {
+        var _a;
+        if (((_a = identifier.parent) === null || _a === void 0 ? void 0 : _a.name) === 'RollupFunctionCall')
+            return;
+        const name = this.nodeText(identifier).toLowerCase();
+        if (name === 'ewma' || name === 'moving_average' || name === 'percentile') {
+            this.pushSemanticDiagnostic(identifier, `rollup function "${name}" requires arguments`, `rollup:${identifier.from}`);
+        }
+        else if (name === 'corr') {
+            this.pushSemanticDiagnostic(identifier, 'rollup function "corr" requires multiple input fields and is only valid in the select clause', `rollup:${identifier.from}`);
+        }
+    }
+    checkRollupFunctionCall(call) {
+        const identifier = call.getChild('RollupIdentifier');
+        const body = call.getChild('RollupFunctionCallBody');
+        if (!identifier || !body)
+            return;
+        const name = this.nodeText(identifier).toLowerCase();
+        const args = this.directChildren(body, 'RollupArg');
+        if (name === 'corr') {
+            this.pushSemanticDiagnostic(identifier, 'rollup function "corr" requires multiple input fields and is only valid in the select clause', `rollup:${identifier.from}`);
+            return;
+        }
+        if (name !== 'ewma' && name !== 'moving_average' && name !== 'percentile') {
+            this.pushSemanticDiagnostic(body, `rollup function "${name}" does not accept arguments in the time range`, `rollup:${call.from}`);
+            return;
+        }
+        const firstValue = args.length === 1 ? this.numericValue(args[0]) : null;
+        if (name === 'ewma' && (firstValue === null || firstValue <= 0 || firstValue > 1)) {
+            this.pushSemanticDiagnostic(body, 'rollup function "ewma" expects one numeric alpha argument in range (0, 1]', `rollup:${call.from}`);
+        }
+        if (name === 'moving_average' && (firstValue === null || !Number.isInteger(firstValue) || firstValue < 1)) {
+            this.pushSemanticDiagnostic(body, 'rollup function "moving_average" expects one positive integer argument', `rollup:${call.from}`);
+        }
+        if (name === 'percentile') {
+            if (firstValue === null || firstValue < 0 || firstValue > 100) {
+                this.pushSemanticDiagnostic(body, 'rollup function "percentile" expects one numeric argument between 0 and 100', `rollup:${call.from}`);
+            }
+        }
+    }
+    checkFunctionCall(call) {
+        const identifier = call.getChild('FunctionIdentifier');
+        const body = call.getChild('FunctionCallBody');
+        if (!identifier || !body)
+            return;
+        const name = this.nodeText(identifier).toLowerCase();
+        const args = this.directChildren(body, 'ArgItem');
+        if (name === 'ewma') {
+            const alpha = args.length === 2 ? this.numericValue(args[1]) : null;
+            if (alpha === null || alpha <= 0 || alpha > 1) {
+                this.pushSemanticDiagnostic(body, 'function "ewma" expects a field and an alpha argument in range (0, 1]', `function:${call.from}`);
+            }
+        }
+        else if (name === 'moving_average') {
+            const window = args.length === 2 ? this.numericValue(args[1]) : null;
+            if (window === null || !Number.isInteger(window) || window < 1) {
+                this.pushSemanticDiagnostic(body, 'function "moving_average" expects a field and a positive integer window', `function:${call.from}`);
+            }
+        }
+        else if (name === 'percentile') {
+            const percentile = args.length === 2 ? this.numericValue(args[1]) : null;
+            if (percentile === null || percentile < 0 || percentile > 100) {
+                this.pushSemanticDiagnostic(body, 'function "percentile" expects a field and a numeric percentile between 0 and 100', `function:${call.from}`);
+            }
+        }
+        else if (name === 'corr' && args.length !== 2) {
+            this.pushSemanticDiagnostic(body, 'function "corr" expects exactly two input fields', `function:${call.from}`);
+        }
+        else if ((name === 'slope' || name === 'zscore' || name === 'mad_score' || name === 'change_score') && args.length !== 1) {
+            this.pushSemanticDiagnostic(body, `function "${name}" expects exactly one input field`, `function:${call.from}`);
+        }
+        else if (/^p(?:50|75|90|95|99)$/.test(name) && args.length !== 1) {
+            this.pushSemanticDiagnostic(body, `function "${name}" expects exactly one input field`, `function:${call.from}`);
+        }
+    }
+    checkOuterFunctionCall(call) {
+        const identifier = call.firstChild;
+        if (!identifier || identifier.name === 'FunctionIdentifier')
+            return;
+        const name = this.nodeText(identifier).toLowerCase();
+        const body = identifier.nextSibling;
+        if (!body)
+            return;
+        const numbers = this.directChildren(body, 'Number');
+        const argument = numbers.length > 0 ? this.numericValue(numbers[numbers.length - 1]) : null;
+        if (name === 'moving_average' || name === 'top' || name === 'bottom') {
+            if (argument === null || !Number.isInteger(argument) || argument < 1) {
+                this.pushSemanticDiagnostic(identifier, `outer function "${name}" expects a positive integer argument`, `outer-function:${call.from}`);
+            }
+        }
+        else if (name === 'round' && argument !== null && (!Number.isInteger(argument) || argument < 0)) {
+            this.pushSemanticDiagnostic(identifier, 'outer function "round" expects a non-negative integer digits argument', `outer-function:${call.from}`);
+        }
+        else if (name === 'dbscan' && argument !== null && (argument <= 0 || argument > 3)) {
+            this.pushSemanticDiagnostic(identifier, 'outer function "dbscan" expects eps in range (0, 3]', `outer-function:${call.from}`);
+        }
+        else if (name === 'forecast' && argument !== null && (!Number.isInteger(argument) || argument < 1)) {
+            this.pushSemanticDiagnostic(identifier, 'outer function "forecast" expects a positive integer steps argument', `outer-function:${call.from}`);
+        }
+        else if (name === 'fill') {
+            const mode = this.directChildren(body, 'Identifier')[0];
+            if (mode && !/^(linear|previous)$/i.test(this.nodeText(mode))) {
+                this.pushSemanticDiagnostic(mode, 'outer function "fill" mode must be "LINEAR" or "PREVIOUS"', `outer-function:${call.from}`);
+            }
+        }
+    }
+    checkProjectionAlias(target) {
+        var _a;
+        const outerAlias = target.getChild('As');
+        const projection = target.getChild('Projection');
+        if (!outerAlias || !projection)
+            return;
+        const items = this.directChildren(projection, 'ProjectionItem');
+        if (items.length !== 1) {
+            this.pushSemanticDiagnostic(outerAlias, 'an alias after ")" requires exactly one projection item', `projection-alias:${target.from}`);
+            return;
+        }
+        if ((_a = items[0].getChild('ProjectionField')) === null || _a === void 0 ? void 0 : _a.getChild('As')) {
+            this.pushSemanticDiagnostic(outerAlias, 'projection expression cannot have both inner and outer aliases', `projection-alias:${target.from}`);
+        }
+    }
+    checkFilterSubqueryOperator(subquery) {
+        const binary = this.findAncestor(subquery.parent, 'BinaryExpr');
+        if (!binary) {
+            this.pushSemanticDiagnostic(subquery, 'filter subquery requires "IN" or "NOT IN"', `filter-subquery:${subquery.from}`);
+            return;
+        }
+        const operators = new Set([
+            'Pow',
+            'Mul',
+            'Div',
+            'Mod',
+            'Add',
+            'Sub',
+            'Eql',
+            'EqlSingle',
+            'Neq',
+            'Lte',
+            'Lss',
+            'Gte',
+            'Gtr',
+            'EqlRegex',
+            'NeqRegex',
+            'In',
+            'NotInSeq',
+            'And',
+            'Or',
+            'DAnd',
+            'DOr',
+        ]);
+        let operator = null;
+        let child = binary.firstChild;
+        while (child) {
+            if (operators.has(child.name)) {
+                operator = child;
+                break;
+            }
+            child = child.nextSibling;
+        }
+        if (!operator || (operator.name !== 'In' && operator.name !== 'NotInSeq') || subquery.from < operator.to) {
+            this.pushSemanticDiagnostic(operator !== null && operator !== void 0 ? operator : subquery, 'filter subquery requires "IN" or "NOT IN"', `filter-subquery:${subquery.from}`);
+        }
+    }
+    checkFieldName(field) {
+        if (field.getChild('JsonField'))
+            return;
+        const text = this.nodeText(field);
+        if (!text || text.startsWith('`') || text.startsWith('"') || text.startsWith("'"))
+            return;
+        if (text.includes('-')) {
+            this.pushSemanticDiagnostic(field, 'field names containing "-" must be enclosed in backticks', `field-name:${field.from}`);
+        }
+    }
+    checkCaseFunction(identifier) {
+        const name = this.nodeText(identifier).toLowerCase();
+        if (name === 'uint' || name === 'bool' || name === 'substr') {
+            this.pushSemanticDiagnostic(identifier, `function "${name}" is not supported inside CASE`, `case-function:${identifier.from}`);
+        }
+    }
+    checkCaseResults(caseExpr) {
+        let clause = caseExpr.firstChild;
+        while (clause) {
+            if (clause.name === 'CaseWhenClause' || clause.name === 'CaseElseClause') {
+                const values = this.directChildren(clause, 'CaseValue');
+                const result = values[values.length - 1];
+                if (result && this.nodeText(result).trim().toLowerCase() === 'end') {
+                    const message = clause.name === 'CaseWhenClause' ? 'CASE result expected after "THEN"' : 'CASE result expected after "ELSE"';
+                    this.pushSemanticDiagnostic(result, message, `case-result:${result.from}`);
+                }
+            }
+            clause = clause.nextSibling;
+        }
+    }
+    checkShowFunctionRequirements(show) {
+        const identifier = show.getChild('ShowIdentifier');
+        const body = show.getChild('FunctionCallBody');
+        if (!identifier || !body)
+            return;
+        const name = this.nodeText(identifier).toLowerCase();
+        const bodyText = this.maskStringsAndLineComments(this.nodeText(body));
+        const hasKeyin = /\bkeyin\s*=/.test(bodyText.toLowerCase());
+        const hasFrom = /\bfrom\s*=/.test(bodyText.toLowerCase());
+        const filter = show.getChild('FilterClause');
+        const hasSourceFilter = Boolean(filter && /@__source__/.test(this.maskStringsAndLineComments(this.nodeText(filter))));
+        if ((name === 'show_tag_value' || name === 'show_tag_value_cardinality' || name === 'show_series_count_by_tag_value') && !hasKeyin) {
+            this.pushSemanticDiagnostic(identifier, `"${name}" requires the named argument "keyin"`, `show:${show.from}:keyin`);
+        }
+        if (name.startsWith('show_series_count_by_') && !hasFrom && !hasSourceFilter) {
+            this.pushSemanticDiagnostic(identifier, `"${name}" requires "from" or an @__source__ filter`, `show:${show.from}:from`);
+        }
+    }
+    pushSemanticDiagnostic(node, message, group) {
+        this.pushSemanticDiagnosticAt(node.from, node.to, message, group);
+    }
+    pushSemanticDiagnosticAt(from, to, message, group) {
+        const diagnostic = this.makeDiagnosticAt(from, Math.max(from + 1, to), message, group);
+        if (!this.diagnostics.some((existing) => this.isSameDiagnostic(existing, diagnostic)))
+            this.appendDiagnostics([diagnostic]);
+    }
+    directChildren(node, name) {
+        const children = [];
+        let child = node.firstChild;
+        while (child) {
+            if (child.name === name)
+                children.push(child);
+            child = child.nextSibling;
+        }
+        return children;
+    }
+    numericValue(node) {
+        if (!node)
+            return null;
+        const number = node.name === 'Number' ? node : node.getChild('Number');
+        if (!number)
+            return null;
+        const sign = node.name !== 'Number' && node.getChild('Sub') ? -1 : 1;
+        const value = sign * Number(this.nodeText(number).replace(/_/g, ''));
+        return Number.isFinite(value) ? value : null;
+    }
+    splitTopLevelSegments(text, separator) {
+        const segments = [];
+        let from = 0;
+        let quote = '';
+        let escaped = false;
+        let depth = 0;
+        for (let index = 0; index < text.length; index += 1) {
+            const char = text[index];
+            if (quote) {
+                if (escaped)
+                    escaped = false;
+                else if (char === '\\' && quote !== '`')
+                    escaped = true;
+                else if (char === quote)
+                    quote = '';
+                continue;
+            }
+            if (char === '"' || char === "'" || char === '`') {
+                quote = char;
+            }
+            else if (char === '(') {
+                depth += 1;
+            }
+            else if (char === ')') {
+                depth = Math.max(0, depth - 1);
+            }
+            else if (char === separator && depth === 0) {
+                segments.push({ from, to: index });
+                from = index + 1;
+            }
+        }
+        segments.push({ from, to: text.length });
+        return segments;
+    }
+    describeUnknownFunction(node) {
+        const contextNames = new Set(['ProjectionField', 'FilterClause', 'HavingClause', 'ByExpr']);
+        let context = node.parent;
+        while (context && !contextNames.has(context.name))
+            context = context.parent;
+        if (!context)
+            return null;
+        const text = this.maskStringsAndLineComments(this.nodeText(context));
+        const functionPattern = /\b([A-Za-z_][A-Za-z0-9_-]*)\s*\(/g;
+        let match = functionPattern.exec(text);
+        while (match) {
+            const name = match[1];
+            const nameFrom = context.from + match.index;
+            if (!this.containsFunctionCallStartingAt(context, nameFrom)) {
+                return this.makeDiagnosticAt(nameFrom, nameFrom + name.length, `unknown function "${name}"`, `unknown-function:${context.from}:${nameFrom}`);
+            }
+            match = functionPattern.exec(text);
+        }
+        return null;
+    }
+    containsFunctionCallStartingAt(node, from) {
+        if ((node.name === 'FunctionCall' || node.name === 'CaseFunctionCall' || node.name === 'FieldCall') && node.from === from)
+            return true;
+        let child = node.firstChild;
+        while (child) {
+            if (child.from <= from && child.to >= from && this.containsFunctionCallStartingAt(child, from))
+                return true;
+            child = child.nextSibling;
+        }
+        return false;
     }
 }
 //# sourceMappingURL=parser.js.map