@cloudcare/codemirror-dql 0.0.55 → 0.0.56

package/dist/cjs/parser/parser.js

@@ -1,49 +1,3105 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Parser = void 0;
+exports.Parser = exports.dqlSyntaxContexts = void 0;
+var common_1 = require("@lezer/common");
 var language_1 = require("@codemirror/language");
+var maxRepairDepth = 8;
+var maxMismatchRepairDepth = 3;
+var analysisBudgetMs = 100;
+var maxDiagnostics = 100;
+var numericClauses = new Map([
+    ['LimitClause', 'LIMIT'],
+    ['OffsetClause', 'OFFSET'],
+    ['SLimitClause', 'SLIMIT'],
+    ['SOffsetClause', 'SOFFSET'],
+]);
+var 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'],
+]);
+var expressionParents = new Set(['BinaryExpr', 'Expr', 'HavingExpr', 'ProjectionExpr']);
+var commaContextBoundaries = new Set(['CaseExpr', 'Query']);
+exports.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',
+};
+var functionCallBodyParents = new Set([
+    'FunctionCallBody',
+    'EvalCallBody',
+    'OuterFunctionCallBody',
+    'RawOuterFunctionCallBody',
+    'RequiredNumberOuterFunctionCallBody',
+    'OptionalNumberOuterFunctionCallBody',
+    'FillOuterFunctionCallBody',
+    'VariadicOuterFunctionCallBody',
+    'RollupFunctionCallBody',
+    'CaseFunctionCallBody',
+]);
 var Parser = /** @class */ (function () {
-    function Parser(state) {
-        this.tree = (0, language_1.syntaxTree)(state);
+    function Parser(state, deadline) {
+        if (deadline === void 0) { deadline = Date.now() + analysisBudgetMs; }
         this.state = state;
+        this.deadline = deadline;
+        var completeTree = this.getCompleteTree(state);
+        this.tree = completeTree !== null && completeTree !== void 0 ? completeTree : common_1.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();
     }
     Parser.prototype.getDiagnostics = function () {
-        return this.diagnostics.sort(function (a, b) {
+        var seen = new Set();
+        var diagnostics = __spreadArray([], __read(this.diagnostics), false).sort(function (a, b) {
             return a.from - b.from;
+        })
+            .filter(function (diagnostic) {
+            var key = "".concat(diagnostic.from, ":").concat(diagnostic.to, ":").concat(diagnostic.message);
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
         });
+        if (diagnostics.length <= maxDiagnostics)
+            return diagnostics;
+        var headCount = Math.floor((maxDiagnostics - 1) / 2);
+        var tailCount = maxDiagnostics - headCount - 1;
+        return __spreadArray(__spreadArray(__spreadArray([], __read(diagnostics.slice(0, headCount)), false), __read(diagnostics.slice(-tailCount)), false), [
+            {
+                severity: 'warning',
+                source: 'DQL syntax',
+                message: "too many syntax errors; showing the first ".concat(headCount, " and last ").concat(tailCount),
+                from: this.state.doc.length,
+                to: this.state.doc.length,
+            },
+        ], false);
     };
     Parser.prototype.analyze = function () {
-        // 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();
+        var 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;
+            }
+            var 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),
+                });
+            }
+        }
+    };
+    Parser.prototype.pushIncompleteAnalysisWarning = function () {
+        var message = 'syntax analysis incomplete; query is too large or deeply nested';
+        if (this.diagnostics.some(function (diagnostic) { return diagnostic.message === message; }))
+            return;
+        this.diagnostics.push({
+            severity: 'warning',
+            source: 'DQL syntax',
+            message: message,
+            from: 0,
+            to: Math.min(1, this.state.doc.length),
+        });
+    };
+    Parser.prototype.getCompleteTree = function (state) {
+        try {
+            if ((0, language_1.syntaxTreeAvailable)(state, state.doc.length)) {
+                var ready = (0, language_1.ensureSyntaxTree)(state, state.doc.length, 0);
+                if (ready && ready.topNode.to >= state.doc.length)
+                    return ready;
+            }
+            var remaining = this.deadline - Date.now();
+            if (remaining <= 0)
+                return null;
+            var tree = (0, language_1.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;
+        }
     };
     Parser.prototype.diagnoseAllErrorNodes = function () {
+        var e_1, _a, e_2, _b, e_3, _c, e_4, _d, e_5, _e, e_6, _f, e_7, _g, e_8, _h;
+        var _this = this;
+        var _j, _k, _l;
         var cursor = this.tree.cursor();
+        var groups = new Set();
+        var diagnostics = [];
+        var quotedQueryInfo = this.findQuotedQueryDelimiterInfo();
+        var _loop_1 = function (fallbackDiagnostic) {
+            if (!diagnostics.some(function (existing) { return _this.isSameDiagnostic(existing, fallbackDiagnostic); }))
+                diagnostics.push(fallbackDiagnostic);
+        };
+        try {
+            for (var _m = __values(quotedQueryInfo.fallbackDiagnostics), _o = _m.next(); !_o.done; _o = _m.next()) {
+                var fallbackDiagnostic = _o.value;
+                _loop_1(fallbackDiagnostic);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_o && !_o.done && (_a = _m.return)) _a.call(_m);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (Date.now() >= this.deadline) {
+            this.appendDiagnostics(diagnostics);
+            return;
+        }
+        if (quotedQueryInfo.fallbackRanges.length > 0) {
+            this.appendDiagnostics(diagnostics);
+            return;
+        }
+        var delimiterIssue = this.getDelimiterIssue();
+        if ((delimiterIssue === null || delimiterIssue === void 0 ? void 0 : delimiterIssue.kind) === 'mismatched') {
+            var delimiterDiagnostic_1 = this.makeDelimiterDiagnostic(delimiterIssue);
+            if (!diagnostics.some(function (existing) { return _this.isSameDiagnostic(existing, delimiterDiagnostic_1); }))
+                diagnostics.push(delimiterDiagnostic_1);
+            if (this.mismatchRepairDepth < maxMismatchRepairDepth) {
+                var repairedDiagnostics = delimiterIssue.recovery === 'delete'
+                    ? this.diagnoseAfterDeletion(delimiterIssue.actualFrom, delimiterIssue.actualFrom + 1)
+                    : this.diagnoseAfterReplacement(delimiterIssue.actualFrom, delimiterIssue.actualFrom + 1, delimiterIssue.close);
+                var _loop_2 = function (repairedDiagnostic) {
+                    if (!diagnostics.some(function (existing) { return _this.isSameDiagnostic(existing, repairedDiagnostic); })) {
+                        diagnostics.push(repairedDiagnostic);
+                    }
+                };
+                try {
+                    for (var repairedDiagnostics_1 = __values(repairedDiagnostics), repairedDiagnostics_1_1 = repairedDiagnostics_1.next(); !repairedDiagnostics_1_1.done; repairedDiagnostics_1_1 = repairedDiagnostics_1.next()) {
+                        var repairedDiagnostic = repairedDiagnostics_1_1.value;
+                        _loop_2(repairedDiagnostic);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (repairedDiagnostics_1_1 && !repairedDiagnostics_1_1.done && (_b = repairedDiagnostics_1.return)) _b.call(repairedDiagnostics_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+            else {
+                var repairedDiagnostics = this.diagnoseAfterBulkDelimiterRecovery(delimiterIssue);
+                var _loop_3 = function (repairedDiagnostic) {
+                    if (!diagnostics.some(function (existing) { return _this.isSameDiagnostic(existing, repairedDiagnostic); })) {
+                        diagnostics.push(repairedDiagnostic);
+                    }
+                };
+                try {
+                    for (var repairedDiagnostics_2 = __values(repairedDiagnostics), repairedDiagnostics_2_1 = repairedDiagnostics_2.next(); !repairedDiagnostics_2_1.done; repairedDiagnostics_2_1 = repairedDiagnostics_2.next()) {
+                        var repairedDiagnostic = repairedDiagnostics_2_1.value;
+                        _loop_3(repairedDiagnostic);
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (repairedDiagnostics_2_1 && !repairedDiagnostics_2_1.done && (_c = repairedDiagnostics_2.return)) _c.call(repairedDiagnostics_2);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            }
+            this.appendDiagnostics(diagnostics);
+            return;
+        }
+        if ((delimiterIssue === null || delimiterIssue === void 0 ? void 0 : delimiterIssue.kind) === 'unexpectedClosing') {
+            var delimiterDiagnostic_2 = this.makeDelimiterDiagnostic(delimiterIssue);
+            if (!diagnostics.some(function (existing) { return _this.isSameDiagnostic(existing, delimiterDiagnostic_2); }))
+                diagnostics.push(delimiterDiagnostic_2);
+            var repairedDiagnostics = this.mismatchRepairDepth < maxMismatchRepairDepth
+                ? this.diagnoseAfterDeletion(delimiterIssue.actualFrom, delimiterIssue.actualFrom + 1)
+                : this.diagnoseAfterBulkUnexpectedClosingRecovery(delimiterIssue);
+            var _loop_4 = function (repairedDiagnostic) {
+                if (!diagnostics.some(function (existing) { return _this.isSameDiagnostic(existing, repairedDiagnostic); }))
+                    diagnostics.push(repairedDiagnostic);
+            };
+            try {
+                for (var repairedDiagnostics_3 = __values(repairedDiagnostics), repairedDiagnostics_3_1 = repairedDiagnostics_3.next(); !repairedDiagnostics_3_1.done; repairedDiagnostics_3_1 = repairedDiagnostics_3.next()) {
+                    var repairedDiagnostic = repairedDiagnostics_3_1.value;
+                    _loop_4(repairedDiagnostic);
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (repairedDiagnostics_3_1 && !repairedDiagnostics_3_1.done && (_d = repairedDiagnostics_3.return)) _d.call(repairedDiagnostics_3);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+            this.appendDiagnostics(diagnostics);
+            return;
+        }
+        if (delimiterIssue &&
+            (delimiterIssue.kind === 'quotedQuery' ||
+                (delimiterIssue.kind === 'quote' && (!delimiterIssue.newline || Boolean((_j = delimiterIssue.repairLineBreaks) === null || _j === void 0 ? void 0 : _j.length))))) {
+            diagnostics.push(this.makeDelimiterDiagnostic(delimiterIssue));
+            if (delimiterIssue.kind === 'quote' && delimiterIssue.newline && ((_k = delimiterIssue.repairLineBreaks) === null || _k === void 0 ? void 0 : _k.length)) {
+                var repairs = this.findStringNewlineRepairs(delimiterIssue);
+                var _loop_5 = function (repair) {
+                    var repairDiagnostic = this_1.makeDiagnosticAt(repair.from, repair.from + 1, 'unescaped newline in string literal', "delimiter:".concat(repair.from));
+                    if (!diagnostics.some(function (existing) { return _this.isSameDiagnostic(existing, repairDiagnostic); }))
+                        diagnostics.push(repairDiagnostic);
+                };
+                var this_1 = this;
+                try {
+                    for (var _p = __values(repairs.slice(0, maxRepairDepth + 1)), _q = _p.next(); !_q.done; _q = _p.next()) {
+                        var repair = _q.value;
+                        _loop_5(repair);
+                    }
+                }
+                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                finally {
+                    try {
+                        if (_q && !_q.done && (_e = _p.return)) _e.call(_p);
+                    }
+                    finally { if (e_5) throw e_5.error; }
+                }
+                var lineBreaks = __spreadArray([], __read(new Set(repairs.flatMap(function (repair) { return repair.lineBreaks; }))), false).sort(function (left, right) { return left - right; });
+                var repairedDiagnostics = this.diagnoseAfterInsertions(lineBreaks, '\\');
+                var _loop_6 = function (repairedDiagnostic) {
+                    if (!diagnostics.some(function (existing) { return _this.isSameDiagnostic(existing, repairedDiagnostic); }))
+                        diagnostics.push(repairedDiagnostic);
+                };
+                try {
+                    for (var repairedDiagnostics_4 = __values(repairedDiagnostics), repairedDiagnostics_4_1 = repairedDiagnostics_4.next(); !repairedDiagnostics_4_1.done; repairedDiagnostics_4_1 = repairedDiagnostics_4.next()) {
+                        var repairedDiagnostic = repairedDiagnostics_4_1.value;
+                        _loop_6(repairedDiagnostic);
+                    }
+                }
+                catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                finally {
+                    try {
+                        if (repairedDiagnostics_4_1 && !repairedDiagnostics_4_1.done && (_f = repairedDiagnostics_4.return)) _f.call(repairedDiagnostics_4);
+                    }
+                    finally { if (e_6) throw e_6.error; }
+                }
+                this.appendDiagnostics(diagnostics);
+                return;
+            }
+            if (this.repairDepth < maxRepairDepth &&
+                (delimiterIssue.repairAt !== undefined || (delimiterIssue.kind === 'quote' && ((_l = delimiterIssue.repairLineBreaks) === null || _l === void 0 ? void 0 : _l.length)))) {
+                var repairedDiagnostics = this.diagnoseAfterInsertion(delimiterIssue.repairAt, delimiterIssue.quote);
+                var _loop_7 = function (repairedDiagnostic) {
+                    if (!diagnostics.some(function (existing) { return _this.isSameDiagnostic(existing, repairedDiagnostic); })) {
+                        diagnostics.push(repairedDiagnostic);
+                    }
+                };
+                try {
+                    for (var repairedDiagnostics_5 = __values(repairedDiagnostics), repairedDiagnostics_5_1 = repairedDiagnostics_5.next(); !repairedDiagnostics_5_1.done; repairedDiagnostics_5_1 = repairedDiagnostics_5.next()) {
+                        var repairedDiagnostic = repairedDiagnostics_5_1.value;
+                        _loop_7(repairedDiagnostic);
+                    }
+                }
+                catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                finally {
+                    try {
+                        if (repairedDiagnostics_5_1 && !repairedDiagnostics_5_1.done && (_g = repairedDiagnostics_5.return)) _g.call(repairedDiagnostics_5);
+                    }
+                    finally { if (e_7) throw e_7.error; }
+                }
+            }
+            this.appendDiagnostics(diagnostics);
+            return;
+        }
+        if (delimiterIssue && delimiterIssue.kind !== 'unclosed') {
+            var delimiterDiagnostic_3 = this.makeDelimiterDiagnostic(delimiterIssue);
+            if (!diagnostics.some(function (existing) { return _this.isSameDiagnostic(existing, delimiterDiagnostic_3); }))
+                diagnostics.push(delimiterDiagnostic_3);
+            if (delimiterDiagnostic_3.group)
+                groups.add(delimiterDiagnostic_3.group);
+        }
+        try {
+            for (var _r = __values(this.findCaseResultDiagnostics()), _s = _r.next(); !_s.done; _s = _r.next()) {
+                var caseDiagnostic = _s.value;
+                if (!caseDiagnostic.group || !groups.has(caseDiagnostic.group)) {
+                    diagnostics.push(caseDiagnostic);
+                    if (caseDiagnostic.group)
+                        groups.add(caseDiagnostic.group);
+                }
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_s && !_s.done && (_h = _r.return)) _h.call(_r);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+        var _loop_8 = function () {
+            var e_9, _t, e_10, _u;
+            if (Date.now() >= this_2.deadline)
+                return "break";
+            if (!cursor.type.isError) {
+                return "continue";
+            }
+            if (quotedQueryInfo.fallbackRanges.some(function (range) {
+                return cursor.from === cursor.to ? cursor.from >= range.from && cursor.from <= range.to : cursor.from < range.to && cursor.to > range.from;
+            })) {
+                return "continue";
+            }
+            var diagnostic = this_2.describeError(cursor.node);
+            if (!diagnostic || (diagnostic.group && groups.has(diagnostic.group))) {
+                return "continue";
+            }
+            if (diagnostics.some(function (existing) { return existing.from === diagnostic.from && existing.to === diagnostic.to; })) {
+                return "continue";
+            }
+            if (diagnostic.group) {
+                groups.add(diagnostic.group);
+            }
+            diagnostics.push(diagnostic);
+            if (diagnostic.repair) {
+                if (this_2.repairDepth < maxRepairDepth) {
+                    var repairedDiagnostics = this_2.diagnoseAfterInsertion(diagnostic.repair.insertAt, diagnostic.repair.text);
+                    var _loop_9 = function (repairedDiagnostic) {
+                        if (!diagnostics.some(function (existing) { return _this.isSameDiagnostic(existing, repairedDiagnostic); })) {
+                            diagnostics.push(repairedDiagnostic);
+                        }
+                    };
+                    try {
+                        for (var repairedDiagnostics_6 = (e_9 = void 0, __values(repairedDiagnostics)), repairedDiagnostics_6_1 = repairedDiagnostics_6.next(); !repairedDiagnostics_6_1.done; repairedDiagnostics_6_1 = repairedDiagnostics_6.next()) {
+                            var repairedDiagnostic = repairedDiagnostics_6_1.value;
+                            _loop_9(repairedDiagnostic);
+                        }
+                    }
+                    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                    finally {
+                        try {
+                            if (repairedDiagnostics_6_1 && !repairedDiagnostics_6_1.done && (_t = repairedDiagnostics_6.return)) _t.call(repairedDiagnostics_6);
+                        }
+                        finally { if (e_9) throw e_9.error; }
+                    }
+                }
+                else if (!this_2.terminalRepairUsed) {
+                    var repairedDiagnostics = this_2.diagnoseAfterTerminalInsertion(diagnostic);
+                    var _loop_10 = function (repairedDiagnostic) {
+                        if (!diagnostics.some(function (existing) { return _this.isSameDiagnostic(existing, repairedDiagnostic); })) {
+                            diagnostics.push(repairedDiagnostic);
+                        }
+                    };
+                    try {
+                        for (var repairedDiagnostics_7 = (e_10 = void 0, __values(repairedDiagnostics)), repairedDiagnostics_7_1 = repairedDiagnostics_7.next(); !repairedDiagnostics_7_1.done; repairedDiagnostics_7_1 = repairedDiagnostics_7.next()) {
+                            var repairedDiagnostic = repairedDiagnostics_7_1.value;
+                            _loop_10(repairedDiagnostic);
+                        }
+                    }
+                    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                    finally {
+                        try {
+                            if (repairedDiagnostics_7_1 && !repairedDiagnostics_7_1.done && (_u = repairedDiagnostics_7.return)) _u.call(repairedDiagnostics_7);
+                        }
+                        finally { if (e_10) throw e_10.error; }
+                    }
+                }
+                return "break";
+            }
+        };
+        var this_2 = this;
         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) {
-                var node = cursor.node.parent;
-                this.diagnostics.push({
-                    severity: 'error',
-                    message: 'unexpected expression',
-                    from: node ? node.from : cursor.from,
-                    to: node ? node.to : cursor.to,
-                });
+            var state_1 = _loop_8();
+            if (state_1 === "break")
+                break;
+        }
+        this.appendDiagnostics(diagnostics);
+    };
+    Parser.prototype.describeError = function (node) {
+        var _a;
+        var delimiterIssue = this.getDelimiterIssue();
+        if (delimiterIssue && delimiterIssue.kind !== 'unclosed' && this.isRelatedDelimiterError(node, delimiterIssue)) {
+            return null;
+        }
+        var parent = node.parent;
+        if (!parent) {
+            return this.makeDiagnostic(node, 'incomplete DQL query');
+        }
+        var parentName = parent.name;
+        var previous = this.siblingSkippingLineComments(node, 'previous');
+        var next = this.siblingSkippingLineComments(node, 'next');
+        var previousText = previous ? this.nodeText(previous) : '';
+        var errorText = this.nodeText(node);
+        var group = "".concat(parentName, ":").concat(parent.from, ":").concat(parent.to, ":").concat(node.from, ":").concat(node.to);
+        var unknownFunctionDiagnostic = this.describeUnknownFunction(node);
+        if (unknownFunctionDiagnostic)
+            return unknownFunctionDiagnostic;
+        var commaRunDiagnostic = this.describeConsecutiveCommaError(node, parent);
+        if (commaRunDiagnostic)
+            return commaRunDiagnostic;
+        if (parentName === 'Namespace') {
+            if (errorText === ':') {
+                return this.makeDiagnosticRepairing(node, 'expected "::" after namespace', node.to, ':', "Namespace:".concat(parent.from, ":").concat(parent.to));
+            }
+            return this.makeDiagnostic(node, 'expected "::" after namespace', "Namespace:".concat(parent.from, ":").concat(parent.to));
+        }
+        if (parentName === 'Query' && node.from === node.to && (previous === null || previous === void 0 ? void 0 : previous.name) === 'Namespace' && !this.containsError(previous)) {
+            var 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:".concat(previous.from, ":").concat(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, exports.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, exports.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, exports.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) {
+                var 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') {
+            var context_1 = parentName === 'InValue' ? 'argument value' : 'filter value';
+            if (this.isCommaSequence(errorText) || this.isCommaOnlyList(parent)) {
+                return this.makeDiagnostic(node, "".concat(context_1, " expected between commas"), this.commaSequenceGroup(parent));
+            }
+            if (errorText === ',' && !previous) {
+                return this.makeDiagnostic(node, "".concat(context_1, " expected before \",\""), group);
+            }
+            if (this.isAdjacentToComma(node, parent)) {
+                return this.makeDiagnostic(node, "".concat(context_1, " expected after \",\""), group);
+            }
+            return this.makeUnexpectedTokenDiagnostic(node, exports.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 \"".concat(previousText, "\""), group);
+            }
+            return this.makeUnexpectedTokenDiagnostic(node, 'expression', group);
+        }
+        var caseWhenClause = this.findAncestor(parent, 'CaseWhenClause');
+        if (caseWhenClause) {
+            var missingCondition = /^\s*when\s+(then)\b/i.exec(this.maskLineComments(this.nodeText(caseWhenClause)));
+            if (missingCondition) {
+                var 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, exports.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));
+        }
+        var numericKeyword = numericClauses.get(parentName);
+        if (numericKeyword) {
+            return this.makeDiagnostic(node, "number expected after \"".concat(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') {
+            var keyword = parentName === 'OrderClause' ? 'ORDER' : 'SORDER';
+            if (!parent.getChild('By')) {
+                return this.makeDiagnostic(node, "expected \"BY\" after \"".concat(keyword, "\""), group);
+            }
+            return this.makeDiagnostic(node, "sort field expected after \"".concat(keyword, " BY\""), group);
+        }
+        if (parentName === 'RollupIdentifier') {
+            var timeClause_1 = this.findAncestor(parent, 'TimeClause');
+            var child = (_a = timeClause_1 === null || timeClause_1 === void 0 ? void 0 : timeClause_1.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, exports.dqlSyntaxContexts.TimeClause, group);
+        }
+        var 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:".concat(timeClause.from, ":").concat(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, exports.dqlSyntaxContexts.FilterClause, group);
+        }
+        if (node.from === this.tree.topNode.to) {
+            var issue = this.getDelimiterIssue();
+            if ((issue === null || issue === void 0 ? void 0 : issue.kind) === 'unclosed') {
+                return this.makeDelimiterDiagnostic(issue);
             }
         }
+        var context = this.findSyntaxContext(parent);
+        return this.makeUnexpectedTokenDiagnostic(node, context, group);
     };
-    Parser.prototype.checkAST = function (node) { };
-    Parser.prototype.addDiagnostic = function (node, msg) {
-        this.diagnostics.push({
+    Parser.prototype.makeUnexpectedTokenDiagnostic = function (node, context, group) {
+        var text = this.nodeText(node);
+        var rawToken = text.length > 20 ? "".concat(text.slice(0, 20), "...") : text;
+        var token = rawToken.replace(/"/g, '\\"');
+        return this.makeDiagnostic(node, token ? "unexpected token \"".concat(token, "\" in ").concat(context) : "incomplete ".concat(context), group);
+    };
+    Parser.prototype.findSyntaxContext = function (node) {
+        var current = node;
+        while (current) {
+            var context = exports.dqlSyntaxContexts[current.name];
+            if (context) {
+                return context;
+            }
+            current = current.parent;
+        }
+        return exports.dqlSyntaxContexts.DQL;
+    };
+    Parser.prototype.makeDiagnostic = function (node, message, group) {
+        return this.makeDiagnosticAt(node.from, node.to, message, group);
+    };
+    Parser.prototype.makeDiagnosticRepairing = function (node, message, insertAt, text, group) {
+        return this.makeDiagnosticRepairingAt(node.from, node.to, message, insertAt, text, group);
+    };
+    Parser.prototype.makeDiagnosticRepairingAt = function (from, to, message, insertAt, text, group) {
+        return __assign(__assign({}, this.makeDiagnosticAt(from, to, message, group)), { repair: { insertAt: insertAt, text: text } });
+    };
+    Parser.prototype.diagnoseAfterInsertion = function (insertAt, text) {
+        var _this = this;
+        var repairedState = this.state.update({ changes: { from: insertAt, insert: text }, filter: false }).state;
+        if (repairedState.doc.length !== this.state.doc.length + text.length) {
+            return [];
+        }
+        var 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(function (diagnostic) { return (__assign(__assign({}, diagnostic), { from: _this.mapRepairedPosition(diagnostic.from, insertAt, text.length), to: _this.mapRepairedPosition(diagnostic.to, insertAt, text.length) })); });
+    };
+    Parser.prototype.diagnoseAfterInsertions = function (insertAts, text) {
+        var _this = this;
+        var positions = __spreadArray([], __read(new Set(insertAts)), false).sort(function (left, right) { return left - right; });
+        if (positions.length === 0)
+            return [];
+        var repairedState = this.state.update({
+            changes: positions.map(function (from) { return ({ from: from, insert: text }); }),
+            filter: false,
+        }).state;
+        if (repairedState.doc.length !== this.state.doc.length + positions.length * text.length) {
+            return [];
+        }
+        var 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(function (diagnostic) { return (__assign(__assign({}, diagnostic), { from: _this.mapRepairedPositionAfterInsertions(diagnostic.from, positions, text.length), to: _this.mapRepairedPositionAfterInsertions(diagnostic.to, positions, text.length) })); });
+    };
+    Parser.prototype.diagnoseAfterReplacement = function (from, to, text) {
+        var repairedState = this.state.update({ changes: { from: from, to: to, insert: text }, filter: false }).state;
+        if (repairedState.doc.length !== this.state.doc.length - (to - from) + text.length) {
+            return [];
+        }
+        var 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();
+    };
+    Parser.prototype.diagnoseAfterDeletion = function (from, to) {
+        var repairedState = this.state.update({ changes: { from: from, to: to, insert: '' }, filter: false }).state;
+        var deletedLength = to - from;
+        if (repairedState.doc.length !== this.state.doc.length - deletedLength) {
+            return [];
+        }
+        var 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(function (diagnostic) { return (__assign(__assign({}, diagnostic), { from: diagnostic.from < from ? diagnostic.from : diagnostic.from + deletedLength, to: diagnostic.to <= from && diagnostic.from < from ? diagnostic.to : diagnostic.to + deletedLength })); });
+    };
+    Parser.prototype.diagnoseAfterBulkDelimiterRecovery = function (issue) {
+        var _a;
+        var firstTransaction = this.state.update({
+            changes: {
+                from: issue.actualFrom,
+                to: issue.actualFrom + 1,
+                insert: issue.recovery === 'delete' ? '' : issue.close,
+            },
+            filter: false,
+        });
+        var bulkChanges = this.findBulkDelimiterRecoveryChanges(firstTransaction.state);
+        if (bulkChanges === null)
+            return [];
+        var bulkTransaction = bulkChanges.length > 0 ? firstTransaction.state.update({ changes: bulkChanges, filter: false }) : null;
+        var repairedState = (_a = bulkTransaction === null || bulkTransaction === void 0 ? void 0 : bulkTransaction.state) !== null && _a !== void 0 ? _a : firstTransaction.state;
+        var repairedParser = new Parser(repairedState, this.deadline);
+        repairedParser.repairDepth = this.repairDepth + 1;
+        repairedParser.mismatchRepairDepth = this.mismatchRepairDepth + 1;
+        repairedParser.terminalRepairUsed = this.terminalRepairUsed;
+        repairedParser.analyze();
+        var diagnostics = repairedParser.getDiagnostics();
+        if (bulkTransaction) {
+            diagnostics = this.mapDiagnosticsThroughChanges(diagnostics, bulkTransaction.changes);
+        }
+        return this.mapDiagnosticsThroughChanges(diagnostics, firstTransaction.changes);
+    };
+    Parser.prototype.diagnoseAfterBulkUnexpectedClosingRecovery = function (issue) {
+        var _a;
+        var firstTransaction = this.state.update({
+            changes: { from: issue.actualFrom, to: issue.actualFrom + 1, insert: '' },
+            filter: false,
+        });
+        var bulkChanges = this.findBulkDelimiterRecoveryChanges(firstTransaction.state);
+        if (bulkChanges === null)
+            return [];
+        var bulkTransaction = bulkChanges.length > 0 ? firstTransaction.state.update({ changes: bulkChanges, filter: false }) : null;
+        var repairedState = (_a = bulkTransaction === null || bulkTransaction === void 0 ? void 0 : bulkTransaction.state) !== null && _a !== void 0 ? _a : firstTransaction.state;
+        var repairedParser = new Parser(repairedState, this.deadline);
+        repairedParser.repairDepth = this.repairDepth + 1;
+        repairedParser.mismatchRepairDepth = this.mismatchRepairDepth + 1;
+        repairedParser.terminalRepairUsed = this.terminalRepairUsed;
+        repairedParser.analyze();
+        var diagnostics = repairedParser.getDiagnostics();
+        if (bulkTransaction)
+            diagnostics = this.mapDiagnosticsThroughChanges(diagnostics, bulkTransaction.changes);
+        return this.mapDiagnosticsThroughChanges(diagnostics, firstTransaction.changes);
+    };
+    Parser.prototype.diagnoseAfterTerminalInsertion = function (diagnostic) {
+        var e_11, _a;
+        var _b;
+        if (!diagnostic.repair)
+            return [];
+        var firstTransaction = this.state.update({
+            changes: { from: diagnostic.repair.insertAt, insert: diagnostic.repair.text },
+            filter: false,
+        });
+        var matchingRepairs = this.findMatchingRepairs(firstTransaction.state, diagnostic.message);
+        if (diagnostic.message === 'expected "::" after namespace') {
+            try {
+                for (var _c = __values(this.findLikelyNamespaceSeparatorInsertions(firstTransaction.state.doc.toString())), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var from = _d.value;
+                    matchingRepairs.push({ from: from, insert: ':' });
+                }
+            }
+            catch (e_11_1) { e_11 = { error: e_11_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_11) throw e_11.error; }
+            }
+        }
+        var uniqueRepairs = matchingRepairs
+            .sort(function (left, right) { return left.from - right.from; })
+            .filter(function (repair, index, repairs) { return index === 0 || repair.from !== repairs[index - 1].from || repair.insert !== repairs[index - 1].insert; });
+        var bulkTransaction = uniqueRepairs.length > 0
+            ? firstTransaction.state.update({
+                changes: uniqueRepairs,
+                filter: false,
+            })
+            : null;
+        var repairedState = (_b = bulkTransaction === null || bulkTransaction === void 0 ? void 0 : bulkTransaction.state) !== null && _b !== void 0 ? _b : firstTransaction.state;
+        var repairedParser = new Parser(repairedState, this.deadline);
+        repairedParser.repairDepth = this.repairDepth + 1;
+        repairedParser.mismatchRepairDepth = this.mismatchRepairDepth;
+        repairedParser.terminalRepairUsed = true;
+        repairedParser.analyze();
+        var diagnostics = repairedParser.getDiagnostics();
+        if (bulkTransaction) {
+            diagnostics = this.mapDiagnosticsThroughChanges(diagnostics, bulkTransaction.changes);
+        }
+        return this.mapDiagnosticsThroughChanges(diagnostics, firstTransaction.changes);
+    };
+    Parser.prototype.findStringNewlineRepairs = function (issue) {
+        var _a;
+        var text = this.state.doc.toString();
+        var repairs = new Map();
+        if ((_a = issue.repairLineBreaks) === null || _a === void 0 ? void 0 : _a.length)
+            repairs.set(issue.from, issue.repairLineBreaks);
+        var 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;
+            var quote = text[cursor.from];
+            if (quote !== '"' && quote !== "'")
+                continue;
+            var 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);
+        }
+        var transparent = this.findLexicalQuotedQueryWrapperDelimiters(this.tree, text);
+        for (var index = 0; index < text.length; index += 1) {
+            if (transparent.has(index))
+                continue;
+            var char = text[index];
+            if (char === '#') {
+                while (index + 1 < text.length && text[index + 1] !== '\n')
+                    index += 1;
+                continue;
+            }
+            if (char.charCodeAt(0) === 96) {
+                var closing = text.indexOf(char, index + 1);
+                if (closing < 0)
+                    break;
+                index = closing;
+                continue;
+            }
+            if (char !== '"' && char !== "'")
+                continue;
+            var recovery = this.findStringNewlineRecovery(text, index + 1, char);
+            if (!recovery)
+                break;
+            if (recovery.lineBreaks.length)
+                repairs.set(index, recovery.lineBreaks);
+            index = recovery.end - 1;
+        }
+        return __spreadArray([], __read(repairs.entries()), false).map(function (_a) {
+            var _b = __read(_a, 2), from = _b[0], lineBreaks = _b[1];
+            return ({ from: from, lineBreaks: lineBreaks });
+        }).sort(function (left, right) { return left.from - right.from; });
+    };
+    Parser.prototype.findLexicalQuotedQueryWrapperDelimiters = function (tree, text) {
+        var transparent = new Set();
+        var cursor = tree.cursor();
+        while (cursor.next()) {
+            if (cursor.name !== 'OuterArgItem' || !cursor.node.getChild('Query'))
+                continue;
+            var opening = cursor.node.getChildren('Queted')[0];
+            if (!opening)
+                continue;
+            var quote = text[opening.from];
+            var closing = this.findLexicalQuotedQueryClosing(text, opening.from, quote);
+            if (closing !== null) {
+                transparent.add(opening.from);
+                transparent.add(closing);
+            }
+        }
+        return transparent;
+    };
+    Parser.prototype.findLexicalQuotedQueryClosing = function (text, opening, wrapperQuote) {
+        var pairs = { '(': ')', '[': ']', '{': '}' };
+        var closers = new Set(Object.values(pairs));
+        var stack = [];
+        var quote = '';
+        var escaped = false;
+        var inComment = false;
+        for (var index = opening + 1; index < text.length; index += 1) {
+            if (Date.now() >= this.deadline)
+                return null;
+            var 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;
+            }
+            var 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;
+    };
+    Parser.prototype.nextNonTriviaCharacter = function (text, start) {
+        var inComment = false;
+        for (var index = start; index < text.length; index += 1) {
+            if (Date.now() >= this.deadline)
+                return '';
+            var char = text[index];
+            if (inComment) {
+                if (char === '\n')
+                    inComment = false;
+            }
+            else if (char === '#') {
+                inComment = true;
+            }
+            else if (!/\s/.test(char)) {
+                return char;
+            }
+        }
+        return '';
+    };
+    Parser.prototype.findMatchingRepairs = function (state, message) {
+        var candidate = new Parser(state, this.deadline);
+        if (!candidate.treeComplete)
+            return [];
+        var repairs = [];
+        var cursor = candidate.tree.cursor();
+        while (cursor.next()) {
+            if (!cursor.type.isError)
+                continue;
+            var 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;
+    };
+    Parser.prototype.mapDiagnosticsThroughChanges = function (diagnostics, changes) {
+        var inverse = changes.invertedDesc;
+        return diagnostics.map(function (diagnostic) { return (__assign(__assign({}, diagnostic), { from: inverse.mapPos(diagnostic.from, 1), to: inverse.mapPos(diagnostic.to, diagnostic.from === diagnostic.to ? 1 : -1) })); });
+    };
+    Parser.prototype.findLikelyNamespaceSeparatorInsertions = function (text) {
+        var masked = this.maskStringsAndLineComments(text);
+        var pattern = /(?:^|\()\s*[A-Za-z_-][A-Za-z0-9_-]*(?:\([^()\n]*\))?\s*:(?!:)/g;
+        var insertions = [];
+        var match = pattern.exec(masked);
+        while (match) {
+            insertions.push(match.index + match[0].lastIndexOf(':') + 1);
+            match = pattern.exec(masked);
+        }
+        return __spreadArray([], __read(new Set(insertions)), false);
+    };
+    Parser.prototype.findBulkDelimiterRecoveryChanges = function (state) {
+        var e_12, _a;
+        var _b, _c, _d;
+        if (Date.now() >= this.deadline)
+            return null;
+        var text = state.doc.toString();
+        var candidate = new Parser(state, this.deadline);
+        if (!candidate.treeComplete)
+            return null;
+        var transparent = candidate.findQuotedQueryDelimiterInfo().transparent;
+        var pairs = { '(': ')', '[': ']', '{': '}' };
+        var closers = new Set(Object.values(pairs));
+        var tokens = [];
+        var quote = '';
+        var escaped = false;
+        var inComment = false;
+        for (var index = 0; index < text.length; index += 1) {
+            if (Date.now() >= this.deadline)
+                return null;
+            var 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: char, from: index });
+            }
+        }
+        var stack = [];
+        var stackCloserCounts = new Map();
+        var futureCloserCounts = new Map();
+        var changes = [];
+        try {
+            for (var tokens_1 = __values(tokens), tokens_1_1 = tokens_1.next(); !tokens_1_1.done; tokens_1_1 = tokens_1.next()) {
+                var token = tokens_1_1.value;
+                if (Date.now() >= this.deadline)
+                    return null;
+                if (pairs[token.char]) {
+                    var closer = pairs[token.char];
+                    stack.push(closer);
+                    stackCloserCounts.set(closer, ((_b = stackCloserCounts.get(closer)) !== null && _b !== void 0 ? _b : 0) + 1);
+                    futureCloserCounts.clear();
+                    continue;
+                }
+                var 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, ((_c = stackCloserCounts.get(expected)) !== null && _c !== void 0 ? _c : 1) - 1);
+                    futureCloserCounts.clear();
+                    continue;
+                }
+                var sameCloserDepth = (_d = stackCloserCounts.get(expected)) !== null && _d !== void 0 ? _d : 0;
+                var futureCloserCount = futureCloserCounts.get(expected);
+                if (futureCloserCount === undefined) {
+                    var 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);
+                }
+            }
+        }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (tokens_1_1 && !tokens_1_1.done && (_a = tokens_1.return)) _a.call(tokens_1);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
+        return changes;
+    };
+    Parser.prototype.isSameDiagnostic = function (left, right) {
+        return left.from === right.from && left.to === right.to && left.message === right.message;
+    };
+    Parser.prototype.appendDiagnostics = function (diagnostics) {
+        var e_13, _a;
+        try {
+            for (var diagnostics_1 = __values(diagnostics), diagnostics_1_1 = diagnostics_1.next(); !diagnostics_1_1.done; diagnostics_1_1 = diagnostics_1.next()) {
+                var diagnostic = diagnostics_1_1.value;
+                var _group = diagnostic.group, _repair = diagnostic.repair, codeMirrorDiagnostic = __rest(diagnostic, ["group", "repair"]);
+                this.diagnostics.push(codeMirrorDiagnostic);
+            }
+        }
+        catch (e_13_1) { e_13 = { error: e_13_1 }; }
+        finally {
+            try {
+                if (diagnostics_1_1 && !diagnostics_1_1.done && (_a = diagnostics_1.return)) _a.call(diagnostics_1);
+            }
+            finally { if (e_13) throw e_13.error; }
+        }
+    };
+    Parser.prototype.mapRepairedPosition = function (position, insertAt, insertedLength) {
+        return position <= insertAt ? position : Math.max(insertAt, position - insertedLength);
+    };
+    Parser.prototype.mapRepairedPositionAfterInsertions = function (position, insertAts, insertedLength) {
+        var e_14, _a;
+        var mapped = position;
+        var priorInsertedLength = 0;
+        try {
+            for (var insertAts_1 = __values(insertAts), insertAts_1_1 = insertAts_1.next(); !insertAts_1_1.done; insertAts_1_1 = insertAts_1.next()) {
+                var insertAt = insertAts_1_1.value;
+                if (position > insertAt + priorInsertedLength) {
+                    mapped -= insertedLength;
+                }
+                priorInsertedLength += insertedLength;
+            }
+        }
+        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        finally {
+            try {
+                if (insertAts_1_1 && !insertAts_1_1.done && (_a = insertAts_1.return)) _a.call(insertAts_1);
+            }
+            finally { if (e_14) throw e_14.error; }
+        }
+        return mapped;
+    };
+    Parser.prototype.makeDiagnosticAt = function (from, to, message, group) {
+        return {
             severity: 'error',
-            message: msg,
-            from: node.from,
-            to: node.to,
+            source: 'DQL syntax',
+            message: message,
+            from: from,
+            to: to,
+            group: group,
+        };
+    };
+    Parser.prototype.nodeText = function (node) {
+        return this.state.sliceDoc(node.from, node.to);
+    };
+    Parser.prototype.isAdjacentToComma = function (node, parent) {
+        var before = this.maskLineComments(this.state.sliceDoc(parent.from, node.from)).trimEnd();
+        var after = this.maskLineComments(this.state.sliceDoc(node.to, parent.to)).trimStart();
+        return before.endsWith(',') || after.startsWith(',') || this.nodeText(node) === ',';
+    };
+    Parser.prototype.isCommaSequence = function (text) {
+        return /^,{2,}$/.test(this.maskLineComments(text).replace(/\s/g, ''));
+    };
+    Parser.prototype.isCommaOnlyList = function (node) {
+        return /^(?:\(,{2,}\)|\[,{2,}\]|\{,{2,}\})$/.test(this.maskLineComments(this.nodeText(node)).replace(/\s/g, ''));
+    };
+    Parser.prototype.commaSequenceGroup = function (node) {
+        return "".concat(node.name, ":").concat(node.from, ":").concat(node.to, ":comma-sequence");
+    };
+    Parser.prototype.describeConsecutiveCommaError = function (node, parent) {
+        var 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',
+        };
+        var context = parent;
+        while (context && !contexts[context.name]) {
+            if (commaContextBoundaries.has(context.name))
+                return null;
+            context = context.parent;
+        }
+        if (!context)
+            return null;
+        var masked = this.maskStringsAndLineComments(this.nodeText(context));
+        var commaRun = /(?:,\s*){2,}/g;
+        var match = commaRun.exec(masked);
+        while (match) {
+            var lastCommaOffset = match.index + match[0].lastIndexOf(',');
+            var runFrom = context.from + match.index;
+            var runTo = context.from + lastCommaOffset + 1;
+            var 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);
+            }
+            var overlapsRun = node.from === node.to
+                ? (node.from > runFrom || !this.hasMissingValueBeforeComma(node)) && node.from <= runTo
+                : node.from < runTo && node.to > runFrom;
+            if (overlapsRun) {
+                var before = masked
+                    .slice(0, match.index)
+                    .replace(/\s/g, '')
+                    .replace(/^[([{]/, '');
+                var message = before ? "".concat(contexts[context.name], " expected after \",\"") : "".concat(contexts[context.name], " expected between commas");
+                return this.makeDiagnosticAt(node.from, node.to, message, "".concat(context.name, ":").concat(context.from, ":").concat(runFrom, ":").concat(runTo, ":comma-sequence"));
+            }
+            match = commaRun.exec(masked);
+        }
+        return null;
+    };
+    Parser.prototype.hasMissingValueBeforeComma = function (node) {
+        var previous = this.siblingSkippingLineComments(node, 'previous');
+        return Boolean(previous && (this.isOperator(previous) || previous.name === 'Then' || previous.name === 'Else'));
+    };
+    Parser.prototype.findCaseExprEndingAt = function (node, position) {
+        var child = node.firstChild;
+        while (child) {
+            if (child.name === 'CaseExpr' && child.to === position)
+                return child;
+            var nested = this.findCaseExprEndingAt(child, position);
+            if (nested)
+                return nested;
+            child = child.nextSibling;
+        }
+        return null;
+    };
+    Parser.prototype.siblingSkippingLineComments = function (node, direction) {
+        var 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;
+    };
+    Parser.prototype.hasErroredSibling = function (node) {
+        var 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;
+    };
+    Parser.prototype.maskLineComments = function (text) {
+        var masked = '';
+        var quote = '';
+        var escaped = false;
+        var inComment = false;
+        for (var index = 0; index < text.length; index += 1) {
+            var 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;
+    };
+    Parser.prototype.maskStringsAndLineComments = function (text) {
+        var masked = '';
+        var quote = '';
+        var escaped = false;
+        var inComment = false;
+        for (var index = 0; index < text.length; index += 1) {
+            var 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;
+    };
+    Parser.prototype.containsError = function (node) {
+        var child = node.firstChild;
+        while (child) {
+            if (child.type.isError || this.containsError(child)) {
+                return true;
+            }
+            child = child.nextSibling;
+        }
+        return false;
+    };
+    Parser.prototype.looksLikeProjectionAfterMissingColon = function (node) {
+        var querySource = node.getChild('QuerySource');
+        return Boolean(querySource && this.containsError(querySource) && !this.containsNode(querySource, 'DColon'));
+    };
+    Parser.prototype.containsNode = function (node, name) {
+        var child = node.firstChild;
+        while (child) {
+            if (child.name === name || this.containsNode(child, name)) {
+                return true;
+            }
+            child = child.nextSibling;
+        }
+        return false;
+    };
+    Parser.prototype.findAncestor = function (node, name) {
+        var current = node;
+        while (current) {
+            if (current.name === name) {
+                return current;
+            }
+            current = current.parent;
+        }
+        return null;
+    };
+    Parser.prototype.caseGroup = function (node) {
+        var current = node;
+        while (current && current.name !== 'CaseWhenClause' && current.name !== 'CaseElseClause' && current.name !== 'CaseExpr') {
+            current = current.parent;
+        }
+        return current ? "".concat(current.name, ":").concat(current.from, ":").concat(current.to) : "Case:".concat(node.from, ":").concat(node.to);
+    };
+    Parser.prototype.findCaseResultDiagnostics = function () {
+        if (this.caseResultDiagnostics)
+            return this.caseResultDiagnostics;
+        var diagnostics = [];
+        var seen = new Set();
+        var cursor = this.tree.cursor();
+        while (cursor.next()) {
+            if (cursor.name !== 'CaseExpr')
+                continue;
+            var clause = cursor.node.firstChild;
+            while (clause) {
+                var isWhenClause = clause.name === 'CaseWhenClause';
+                var isElseClause = clause.name === 'CaseElseClause';
+                var recovery = this.siblingSkippingLineComments(clause, 'next');
+                if ((isWhenClause || isElseClause) && (recovery === null || recovery === void 0 ? void 0 : recovery.type.isError)) {
+                    var clauseText = this.maskStringsAndLineComments(this.nodeText(clause));
+                    var match = isWhenClause ? /\bthen\s+(else|end)\b/i.exec(clauseText) : /\belse\s+(end)\b/i.exec(clauseText);
+                    if (match) {
+                        var marker = match[1];
+                        if (marker.toLowerCase() === 'end' && recovery.from !== recovery.to) {
+                            clause = clause.nextSibling;
+                            continue;
+                        }
+                        var markerOffset = match.index + match[0].toLowerCase().lastIndexOf(marker.toLowerCase());
+                        var from = clause.from + markerOffset;
+                        var message = isWhenClause ? 'CASE result expected after "THEN"' : 'CASE result expected after "ELSE"';
+                        var key = "".concat(from, ":").concat(message);
+                        if (!seen.has(key)) {
+                            diagnostics.push(this.makeDiagnosticAt(from, from + marker.length, message, "CaseResult:".concat(from)));
+                            seen.add(key);
+                        }
+                        this.caseResultRecoveryErrors.add(this.nodeRangeKey(recovery));
+                    }
+                }
+                clause = clause.nextSibling;
+            }
+        }
+        this.caseResultDiagnostics = diagnostics;
+        return diagnostics;
+    };
+    Parser.prototype.nodeRangeKey = function (node) {
+        return "".concat(node.from, ":").concat(node.to);
+    };
+    Parser.prototype.isOperator = function (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);
+    };
+    Parser.prototype.getDelimiterIssue = function () {
+        if (this.delimiterIssue === undefined) {
+            this.delimiterIssue = this.findDelimiterIssue(this.tree.topNode.to);
+        }
+        return this.delimiterIssue;
+    };
+    Parser.prototype.makeDelimiterDiagnostic = function (issue) {
+        if (issue.kind === 'quote' || issue.kind === 'quotedQuery') {
+            var context = issue.kind === 'quote' ? 'string literal' : 'quoted query';
+            var message = issue.kind === 'quote' && issue.newline
+                ? 'unescaped newline in string literal'
+                : "unterminated ".concat(context, "; expected closing ").concat(this.quoteName(issue.quote));
+            return this.makeDiagnosticAt(issue.from, issue.from + 1, message, "delimiter:".concat(issue.from));
+        }
+        if (issue.kind === 'mismatched') {
+            var message = issue.context
+                ? "expected ".concat(this.quoteName(issue.close), " instead of ").concat(this.quoteName(issue.actual), " to close ").concat(issue.context)
+                : issue.recovery === 'delete'
+                    ? "unexpected closing delimiter \"".concat(issue.actual, "\" before \"").concat(issue.close, "\"")
+                    : "expected \"".concat(issue.close, "\" instead of \"").concat(issue.actual, "\" to close \"").concat(issue.open, "\"");
+            return this.makeDiagnosticAt(issue.actualFrom, issue.actualFrom + 1, message, "delimiter:".concat(issue.from));
+        }
+        if (issue.kind === 'unexpectedClosing') {
+            return this.makeDiagnosticAt(issue.actualFrom, issue.actualFrom + 1, "unexpected closing delimiter \"".concat(issue.actual, "\""), "delimiter:".concat(issue.actualFrom));
+        }
+        return this.makeDiagnosticAt(issue.at, issue.at, "expected \"".concat(issue.close, "\" to close \"").concat(issue.open, "\""), "delimiter:".concat(issue.from));
+    };
+    Parser.prototype.isRelatedDelimiterError = function (node, issue) {
+        if (issue.kind === 'quote' || issue.kind === 'quotedQuery') {
+            if (node.from !== node.to) {
+                return node.from < issue.end && node.to > issue.from;
+            }
+            var 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;
+    };
+    Parser.prototype.quoteName = function (quote) {
+        return quote === '"' ? 'double quote' : quote === "'" ? 'single quote' : 'backtick';
+    };
+    Parser.prototype.findQuotedQueryDelimiterInfo = function () {
+        var e_15, _a, e_16, _b, e_17, _c;
+        var _d;
+        if (this.quotedQueryDelimiterInfo)
+            return this.quotedQueryDelimiterInfo;
+        var transparent = new Set();
+        var issues = new Map();
+        var fallbackRanges = [];
+        var fallbackDiagnostics = [];
+        var addFallbackRange = function (range) {
+            if (range && !fallbackRanges.some(function (existing) { return existing.from === range.from && existing.to === range.to; })) {
+                fallbackRanges.push(range);
+            }
+        };
+        var pending = null;
+        var 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' && ((_d = cursor.node.parent) === null || _d === void 0 ? void 0 : _d.name) !== 'OuterArgItem') {
+                addFallbackRange(this.findFallbackQuotedQueryRangeFromOpening(cursor.from));
+            }
+            if (cursor.name !== 'OuterArgItem') {
+                continue;
+            }
+            var quoted = [];
+            var child = cursor.node.firstChild;
+            while (child) {
+                if (child.name === 'Queted')
+                    quoted.push(child);
+                child = child.nextSibling;
+            }
+            try {
+                for (var quoted_1 = (e_15 = void 0, __values(quoted)), quoted_1_1 = quoted_1.next(); !quoted_1_1.done; quoted_1_1 = quoted_1.next()) {
+                    var quote = quoted_1_1.value;
+                    transparent.add(quote.from);
+                }
+            }
+            catch (e_15_1) { e_15 = { error: e_15_1 }; }
+            finally {
+                try {
+                    if (quoted_1_1 && !quoted_1_1.done && (_a = quoted_1.return)) _a.call(quoted_1);
+                }
+                finally { if (e_15) throw e_15.error; }
+            }
+            if (quoted.length >= 2) {
+                var first = quoted[0];
+                var last = quoted[quoted.length - 1];
+                var expected = this.nodeText(first);
+                var actual = this.nodeText(last);
+                if (expected !== actual) {
+                    issues.set(last.from, {
+                        kind: 'mismatched',
+                        open: expected,
+                        close: expected,
+                        from: first.from,
+                        actual: actual,
+                        actualFrom: last.from,
+                        context: 'quoted query',
+                    });
+                }
+                else {
+                    var range = { from: first.from, to: last.to };
+                    var 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) {
+                var quote = quoted[0];
+                var wrapperQuote = this.nodeText(quote);
+                var lexicalClosing = this.findLexicalQuotedQueryClosing(this.state.doc.toString(), quote.from, wrapperQuote);
+                var fallbackRange = lexicalClosing === null ? null : { from: quote.from, to: lexicalClosing + 1 };
+                if (fallbackRange && this.isFallbackQuotedQueryRange(fallbackRange.from, fallbackRange.to)) {
+                    addFallbackRange(fallbackRange);
+                }
+                else {
+                    var issue = {
+                        kind: 'quotedQuery',
+                        quote: wrapperQuote,
+                        from: quote.from,
+                        end: cursor.to,
+                        repairAt: cursor.to,
+                    };
+                    if (!pending || issue.from < pending.from)
+                        pending = issue;
+                }
+            }
+        }
+        fallbackRanges.sort(function (left, right) { return left.from - right.from || right.to - left.to; });
+        var disjointFallbackRanges = [];
+        try {
+            for (var fallbackRanges_1 = __values(fallbackRanges), fallbackRanges_1_1 = fallbackRanges_1.next(); !fallbackRanges_1_1.done; fallbackRanges_1_1 = fallbackRanges_1.next()) {
+                var range = fallbackRanges_1_1.value;
+                var previous = disjointFallbackRanges[disjointFallbackRanges.length - 1];
+                if (!previous || range.from >= previous.to)
+                    disjointFallbackRanges.push(range);
+            }
+        }
+        catch (e_16_1) { e_16 = { error: e_16_1 }; }
+        finally {
+            try {
+                if (fallbackRanges_1_1 && !fallbackRanges_1_1.done && (_b = fallbackRanges_1.return)) _b.call(fallbackRanges_1);
+            }
+            finally { if (e_16) throw e_16.error; }
+        }
+        fallbackRanges.splice.apply(fallbackRanges, __spreadArray([0, fallbackRanges.length], __read(disjointFallbackRanges), false));
+        try {
+            for (var fallbackRanges_2 = __values(fallbackRanges), fallbackRanges_2_1 = fallbackRanges_2.next(); !fallbackRanges_2_1.done; fallbackRanges_2_1 = fallbackRanges_2.next()) {
+                var range = fallbackRanges_2_1.value;
+                transparent.add(range.from);
+                transparent.add(range.to - 1);
+            }
+        }
+        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+        finally {
+            try {
+                if (fallbackRanges_2_1 && !fallbackRanges_2_1.done && (_c = fallbackRanges_2.return)) _c.call(fallbackRanges_2);
+            }
+            finally { if (e_17) throw e_17.error; }
+        }
+        fallbackDiagnostics.push.apply(fallbackDiagnostics, __spreadArray([], __read(this.diagnoseFallbackQuotedQueries(fallbackRanges)), false));
+        this.quotedQueryDelimiterInfo = { transparent: transparent, issues: issues, pending: pending, fallbackRanges: fallbackRanges, fallbackDiagnostics: fallbackDiagnostics };
+        return this.quotedQueryDelimiterInfo;
+    };
+    Parser.prototype.findFallbackQuotedQueryRange = function (node) {
+        var e_18, _a;
+        var _b;
+        var indexItem = node.parent;
+        var indexExpr = indexItem === null || indexItem === void 0 ? void 0 : indexItem.parent;
+        var 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;
+        var 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' && ((_b = this.siblingSkippingLineComments(namespace, 'next')) === null || _b === void 0 ? void 0 : _b.name) === 'DColon')
+            return null;
+        var raw = this.nodeText(node);
+        var quote = raw[0];
+        if (!['"', "'", '`'].includes(quote))
+            return null;
+        var text = this.state.doc.toString();
+        var lexicalClosing = this.findLexicalQuotedQueryClosing(text, node.from, quote);
+        var candidates = [lexicalClosing === null ? null : lexicalClosing + 1, raw.length >= 2 && raw[raw.length - 1] === quote ? node.to : null];
+        try {
+            for (var _c = __values(__spreadArray([], __read(new Set(candidates)), false)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var to = _d.value;
+                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: to };
+            }
+        }
+        catch (e_18_1) { e_18 = { error: e_18_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_18) throw e_18.error; }
+        }
+        return null;
+    };
+    Parser.prototype.findFallbackQuotedQueryRangeFromOpening = function (from) {
+        var quote = this.state.sliceDoc(from, from + 1);
+        if (!['"', "'", '`'].includes(quote))
+            return null;
+        var closing = this.findLexicalQuotedQueryClosing(this.state.doc.toString(), from, quote);
+        if (closing === null || closing <= from)
+            return null;
+        var to = closing + 1;
+        return this.isFallbackQuotedQueryRange(from, to) ? { from: from, to: to } : null;
+    };
+    Parser.prototype.isFallbackQuotedQueryRange = function (from, to) {
+        var originalPayload = this.state.sliceDoc(from + 1, to - 1);
+        if (!this.formsOuterQuotedQuery(from, to, 'M::cpu:(usage)'))
+            return false;
+        if (this.isQueryPayload(originalPayload))
+            return true;
+        var bulkRepairedPayload = this.repairScopedDelimiterMismatches(originalPayload);
+        if (bulkRepairedPayload && this.isQueryPayload(bulkRepairedPayload))
+            return true;
+        var queue = [{ payload: originalPayload, depth: 0 }];
+        var seen = new Set();
+        while (queue.length > 0 && Date.now() < this.deadline) {
+            var candidate = queue.shift();
+            if (seen.has(candidate.payload))
+                continue;
+            seen.add(candidate.payload);
+            var 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;
+    };
+    Parser.prototype.isQueryPayload = function (payload) {
+        var _a;
+        var payloadState = this.state.update({ changes: { from: 0, to: this.state.doc.length, insert: payload }, filter: false }).state;
+        var payloadTree = this.getCompleteTree(payloadState);
+        if (!payloadTree)
+            return false;
+        var 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;
+    };
+    Parser.prototype.diagnoseFallbackQuotedQueries = function (ranges) {
+        var e_19, _a, e_20, _b, e_21, _c, e_22, _d;
+        var _this = this;
+        if (ranges.length === 0)
+            return [];
+        var diagnostics = [];
+        var canonicalPayload = 'M::cpu:(usage)';
+        try {
+            for (var ranges_1 = __values(ranges), ranges_1_1 = ranges_1.next(); !ranges_1_1.done; ranges_1_1 = ranges_1.next()) {
+                var range = ranges_1_1.value;
+                if (Date.now() >= this.deadline)
+                    return diagnostics;
+                var payload = this.state.sliceDoc(range.from + 1, range.to - 1);
+                var payloadState = this.state.update({ changes: { from: 0, to: this.state.doc.length, insert: payload }, filter: false }).state;
+                var payloadParser = new Parser(payloadState, this.deadline);
+                payloadParser.repairDepth = this.repairDepth;
+                payloadParser.mismatchRepairDepth = this.mismatchRepairDepth;
+                payloadParser.terminalRepairUsed = this.terminalRepairUsed;
+                payloadParser.analyze();
+                var _loop_11 = function (diagnostic) {
+                    var mapped = __assign(__assign({}, diagnostic), { from: diagnostic.from + range.from + 1, to: diagnostic.to + range.from + 1 });
+                    if (!diagnostics.some(function (existing) { return _this.isSameDiagnostic(existing, mapped); }))
+                        diagnostics.push(mapped);
+                };
+                try {
+                    for (var _e = (e_20 = void 0, __values(payloadParser.getDiagnostics())), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var diagnostic = _f.value;
+                        _loop_11(diagnostic);
+                    }
+                }
+                catch (e_20_1) { e_20 = { error: e_20_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_20) throw e_20.error; }
+                }
+            }
+        }
+        catch (e_19_1) { e_19 = { error: e_19_1 }; }
+        finally {
+            try {
+                if (ranges_1_1 && !ranges_1_1.done && (_a = ranges_1.return)) _a.call(ranges_1);
+            }
+            finally { if (e_19) throw e_19.error; }
+        }
+        if (Date.now() >= this.deadline)
+            return diagnostics;
+        var changes = ranges.map(function (range) { return ({ from: range.from + 1, to: range.to - 1, insert: canonicalPayload }); });
+        var probeTransaction = this.state.update({ changes: changes, filter: false });
+        var insertedRanges = [];
+        var offset = 0;
+        try {
+            for (var ranges_2 = __values(ranges), ranges_2_1 = ranges_2.next(); !ranges_2_1.done; ranges_2_1 = ranges_2.next()) {
+                var range = ranges_2_1.value;
+                var from = range.from + 1 + offset;
+                insertedRanges.push({ from: from, to: from + canonicalPayload.length });
+                offset += canonicalPayload.length - (range.to - range.from - 2);
+            }
+        }
+        catch (e_21_1) { e_21 = { error: e_21_1 }; }
+        finally {
+            try {
+                if (ranges_2_1 && !ranges_2_1.done && (_c = ranges_2.return)) _c.call(ranges_2);
+            }
+            finally { if (e_21) throw e_21.error; }
+        }
+        var probeParser = new Parser(probeTransaction.state, this.deadline);
+        probeParser.repairDepth = this.repairDepth;
+        probeParser.mismatchRepairDepth = this.mismatchRepairDepth;
+        probeParser.terminalRepairUsed = this.terminalRepairUsed;
+        probeParser.analyze();
+        var outerDiagnostics = probeParser.getDiagnostics().filter(function (diagnostic) {
+            return !insertedRanges.some(function (range) {
+                return diagnostic.from === diagnostic.to
+                    ? diagnostic.from >= range.from && diagnostic.from <= range.to
+                    : diagnostic.from < range.to && diagnostic.to > range.from;
+            });
         });
+        var _loop_12 = function (diagnostic) {
+            if (!diagnostics.some(function (existing) { return _this.isSameDiagnostic(existing, diagnostic); }))
+                diagnostics.push(diagnostic);
+        };
+        try {
+            for (var _g = __values(this.mapDiagnosticsThroughChanges(outerDiagnostics, probeTransaction.changes)), _h = _g.next(); !_h.done; _h = _g.next()) {
+                var diagnostic = _h.value;
+                _loop_12(diagnostic);
+            }
+        }
+        catch (e_22_1) { e_22 = { error: e_22_1 }; }
+        finally {
+            try {
+                if (_h && !_h.done && (_d = _g.return)) _d.call(_g);
+            }
+            finally { if (e_22) throw e_22.error; }
+        }
+        return diagnostics;
+    };
+    Parser.prototype.repairScopedDelimiterMismatches = function (text) {
+        var e_23, _a;
+        var _b, _c, _d;
+        var pairs = { '(': ')', '[': ']', '{': '}' };
+        var closers = new Set(Object.values(pairs));
+        var stack = [];
+        var stackCloserCounts = new Map();
+        var futureCloserCounts = new Map();
+        var changes = [];
+        var transparent = new Set();
+        var quote = '';
+        var escaped = false;
+        var inComment = false;
+        for (var index = 0; index < text.length; index += 1) {
+            if (Date.now() >= this.deadline)
+                return null;
+            var 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]) {
+                var closer = pairs[char];
+                stack.push(closer);
+                stackCloserCounts.set(closer, ((_b = stackCloserCounts.get(closer)) !== null && _b !== void 0 ? _b : 0) + 1);
+                futureCloserCounts.clear();
+            }
+            else if (closers.has(char)) {
+                var expected = stack[stack.length - 1];
+                if (char === expected) {
+                    stack.pop();
+                    stackCloserCounts.set(expected, ((_c = stackCloserCounts.get(expected)) !== null && _c !== void 0 ? _c : 1) - 1);
+                    futureCloserCounts.clear();
+                    continue;
+                }
+                if (!expected) {
+                    changes.push({ from: index, to: index + 1, insert: '' });
+                    continue;
+                }
+                var sameCloserDepth = (_d = stackCloserCounts.get(expected)) !== null && _d !== void 0 ? _d : 0;
+                var futureCloserCount = futureCloserCounts.get(expected);
+                if (futureCloserCount === undefined) {
+                    var 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;
+        var missingClosers = __spreadArray([], __read(stack), false).reverse().join('');
+        if (changes.length === 0 && !missingClosers)
+            return null;
+        var repaired = '';
+        var copiedTo = 0;
+        try {
+            for (var changes_1 = __values(changes), changes_1_1 = changes_1.next(); !changes_1_1.done; changes_1_1 = changes_1.next()) {
+                var change = changes_1_1.value;
+                repaired += text.slice(copiedTo, change.from) + change.insert;
+                copiedTo = change.to;
+            }
+        }
+        catch (e_23_1) { e_23 = { error: e_23_1 }; }
+        finally {
+            try {
+                if (changes_1_1 && !changes_1_1.done && (_a = changes_1.return)) _a.call(changes_1);
+            }
+            finally { if (e_23) throw e_23.error; }
+        }
+        return repaired + text.slice(copiedTo) + missingClosers;
+    };
+    Parser.prototype.findFirstDelimiterMismatch = function (text) {
+        var pairs = { '(': ')', '[': ']', '{': '}' };
+        var closers = new Set(Object.values(pairs));
+        var stack = [];
+        var quote = '';
+        var escaped = false;
+        var inComment = false;
+        for (var index = 0; index < text.length; index += 1) {
+            var 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)) {
+                var expected = stack[stack.length - 1];
+                if (char !== expected)
+                    return { from: index, expected: expected };
+                stack.pop();
+            }
+        }
+        return null;
+    };
+    Parser.prototype.formsOuterQuotedQuery = function (from, to, payload) {
+        var repairedState = this.state.update({ changes: { from: from + 1, to: to - 1, insert: payload }, filter: false }).state;
+        var repairedTree = this.getCompleteTree(repairedState);
+        if (!repairedTree)
+            return false;
+        var wrapperQuote = this.state.sliceDoc(from, from + 1);
+        var expectedClosing = from + payload.length + 1;
+        var cursor = repairedTree.cursor();
+        while (cursor.next()) {
+            if (cursor.name !== 'OuterArgItem' || cursor.from !== from)
+                continue;
+            var query = cursor.node.getChild('Query');
+            var quotes = cursor.node.getChildren('Queted');
+            var openingQuote = quotes.find(function (quote) { return quote.from === from; });
+            var closingQuote = quotes.find(function (quote) { return 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;
+    };
+    Parser.prototype.findDelimiterIssue = function (end, scoreRecovery) {
+        var _a, _b, _c, _d, _e;
+        if (scoreRecovery === void 0) { scoreRecovery = true; }
+        var text = this.state.sliceDoc(0, end);
+        var stack = [];
+        var pairs = { '(': ')', '[': ']', '{': '}' };
+        var closingDelimiters = new Set(Object.values(pairs));
+        var quote = '';
+        var quoteFrom = -1;
+        var quoteRepairCandidates = [];
+        var escaped = false;
+        var quotedQueryDelimiters = this.findQuotedQueryDelimiterInfo();
+        var quotedQueryOuterDepth = -1;
+        var _loop_13 = function (index) {
+            if ((index & 255) === 0 && Date.now() >= this_3.deadline)
+                return { value: null };
+            var char = text[index];
+            var fallbackRange = quotedQueryDelimiters.fallbackRanges.find(function (range) { return index >= range.from && index < range.to; });
+            if (fallbackRange) {
+                index = fallbackRange.to - 1;
+                return out_index_1 = index, "continue";
+            }
+            var quotedQueryIssue = quotedQueryDelimiters.issues.get(index);
+            if (quotedQueryIssue)
+                return { value: 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;
+                }
+                return out_index_1 = index, "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 !== '`') {
+                    var quotedQueryRepairAt = this_3.findVerifiedQuotedQueryRepairAt(text, quoteFrom, quote, (_b = stack[stack.length - 1]) === null || _b === void 0 ? void 0 : _b.close, end);
+                    if (quotedQueryRepairAt !== null) {
+                        return { value: {
+                                kind: 'quotedQuery',
+                                quote: quote,
+                                from: quoteFrom,
+                                end: end,
+                                repairAt: quotedQueryRepairAt,
+                            } };
+                    }
+                    var recovery = this_3.findStringNewlineRecovery(text, quoteFrom + 1, quote);
+                    return { value: {
+                            kind: 'quote',
+                            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);
+                }
+                return out_index_1 = index, "continue";
+            }
+            if (char === '"' || char === "'" || char === '`') {
+                quote = char;
+                quoteFrom = index;
+                quoteRepairCandidates = [];
+                return out_index_1 = index, "continue";
+            }
+            if (char === '#') {
+                while (index + 1 < text.length && text[index + 1] !== '\n') {
+                    index += 1;
+                }
+                return out_index_1 = index, "continue";
+            }
+            if (pairs[char]) {
+                stack.push({ open: char, close: pairs[char], from: index });
+                return out_index_1 = index, "continue";
+            }
+            var 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)) {
+                var sameCloserDepth = stack.filter(function (entry) { return entry.close === last.close; }).length;
+                var futureCloserCount = scoreRecovery
+                    ? this_3.countFutureClosersAtCurrentDepth(text, index + 1, last.close, quotedQueryDelimiters.transparent)
+                    : 0;
+                return { value: {
+                        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_3.deadline
+                                    ? 'replace'
+                                    : this_3.chooseMismatchRecovery(index, index + 1, last.close)
+                            : 'replace',
+                    } };
+            }
+            else if (!last && closingDelimiters.has(char) && !this_3.hasPrecedingErrorEndingAt(index)) {
+                return { value: { kind: 'unexpectedClosing', actual: char, actualFrom: index } };
+            }
+            out_index_1 = index;
+        };
+        var this_3 = this, out_index_1;
+        for (var index = 0; index < text.length; index += 1) {
+            var state_2 = _loop_13(index);
+            index = out_index_1;
+            if (typeof state_2 === "object")
+                return state_2.value;
+        }
+        if (quote) {
+            return {
+                kind: 'quote',
+                quote: quote,
+                from: quoteFrom,
+                end: 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;
+        var unclosed = stack[stack.length - 1];
+        return unclosed ? __assign(__assign({ kind: 'unclosed' }, unclosed), { at: end }) : null;
+    };
+    Parser.prototype.hasPrecedingErrorEndingAt = function (position) {
+        var cursor = this.tree.cursor();
+        while (cursor.next()) {
+            if (cursor.type.isError && cursor.from < position && cursor.to === position)
+                return true;
+        }
+        return false;
+    };
+    Parser.prototype.countFutureClosersAtCurrentDepth = function (text, start, closer, transparent) {
+        var pairs = { '(': ')', '[': ']', '{': '}' };
+        var closingDelimiters = new Set(Object.values(pairs));
+        var nestedClosers = [];
+        var quote = '';
+        var escaped = false;
+        var inComment = false;
+        var count = 0;
+        for (var index = start; index < text.length; index += 1) {
+            if (Date.now() >= this.deadline)
+                return null;
+            var 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;
+    };
+    Parser.prototype.chooseQuoteRepairAt = function (text, quoteFrom, quote, expectedCloser, closerCandidates, end) {
+        var _a;
+        var quotedQueryRepairAt = this.findVerifiedQuotedQueryRepairAt(text, quoteFrom, quote, expectedCloser, end);
+        if (quotedQueryRepairAt !== null)
+            return quotedQueryRepairAt;
+        var ordinaryPositions = closerCandidates.length > 0 ? __spreadArray([], __read(new Set(closerCandidates)), false).sort(function (left, right) { return left - right; }) : [end];
+        var repairs = [];
+        var _loop_14 = function (index) {
+            var repair = this_4.scoreQuoteRepairCandidate(ordinaryPositions[index], quote, quoteFrom);
+            repairs.push(repair);
+            var localEnd = ((_a = ordinaryPositions[index + 1]) !== null && _a !== void 0 ? _a : ordinaryPositions[index]) + quote.length;
+            if (repair.complete && !repair.errorPositions.some(function (_a) {
+                var from = _a.from, to = _a.to;
+                return from <= localEnd && to >= quoteFrom;
+            })) {
+                return { value: repair.insertAt };
+            }
+        };
+        var this_4 = this;
+        for (var index = 0; index < ordinaryPositions.length && Date.now() < this.deadline; index += 1) {
+            var state_3 = _loop_14(index);
+            if (typeof state_3 === "object")
+                return state_3.value;
+        }
+        if (repairs.length < ordinaryPositions.length)
+            return undefined;
+        if (!repairs.some(function (_a) {
+            var complete = _a.complete;
+            return complete;
+        }))
+            return end;
+        return this.pickQuoteRepair(repairs, end);
+    };
+    Parser.prototype.findVerifiedQuotedQueryRepairAt = function (text, quoteFrom, quote, expectedCloser, end) {
+        var _this = this;
+        var candidate = expectedCloser ? this.findQuotedQueryRepairCandidate(text, quoteFrom + 1, quote, expectedCloser) : null;
+        var positions = __spreadArray([], __read(new Set([candidate, end].filter(function (position) { return position !== null; }))), false);
+        var repairs = positions.map(function (insertAt) { return _this.scoreQuoteRepairCandidate(insertAt, quote, quoteFrom); }).filter(function (repair) { return repair.quotedQuery; });
+        return repairs.length > 0 ? this.pickQuoteRepair(repairs, end) : null;
+    };
+    Parser.prototype.scoreQuoteRepairCandidate = function (insertAt, quote, quoteFrom) {
+        if (Date.now() >= this.deadline) {
+            return { insertAt: insertAt, errors: Number.POSITIVE_INFINITY, errorPositions: [], quotedQuery: false, complete: false };
+        }
+        var state = this.state.update({ changes: { from: insertAt, insert: quote }, filter: false }).state;
+        var tree = this.getCompleteTree(state);
+        if (!tree) {
+            return { insertAt: insertAt, errors: Number.POSITIVE_INFINITY, errorPositions: [], quotedQuery: false, complete: false };
+        }
+        var cursor = tree.cursor();
+        var errors = 0;
+        var errorPositions = [];
+        var quotedQuery = false;
+        while (cursor.next()) {
+            if (cursor.type.isError) {
+                errors += 1;
+                errorPositions.push({ from: cursor.from, to: cursor.to });
+            }
+            if (cursor.name !== 'OuterArgItem')
+                continue;
+            var quoted = [];
+            var 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(function (node) { return node.from === insertAt; })) {
+                quotedQuery = true;
+            }
+        }
+        return { insertAt: insertAt, errors: errors, errorPositions: errorPositions, quotedQuery: quotedQuery, complete: true };
+    };
+    Parser.prototype.pickQuoteRepair = function (candidates, end) {
+        return candidates.sort(function (left, right) {
+            if (left.errors !== right.errors)
+                return left.errors - right.errors;
+            var leftAtEnd = left.insertAt === end;
+            var rightAtEnd = right.insertAt === end;
+            if (leftAtEnd !== rightAtEnd)
+                return leftAtEnd ? 1 : -1;
+            return right.insertAt - left.insertAt;
+        })[0].insertAt;
+    };
+    Parser.prototype.findQuotedQueryRepairCandidate = function (text, start, outerQuote, expectedCloser) {
+        var pairs = { '(': ')', '[': ']', '{': '}' };
+        var closingDelimiters = new Set(Object.values(pairs));
+        var stack = [];
+        var quote = '';
+        var escaped = false;
+        var outerEscaped = false;
+        var inComment = false;
+        for (var index = start; index < text.length; index += 1) {
+            var 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;
+    };
+    Parser.prototype.chooseMismatchRecovery = function (from, to, expectedCloser) {
+        var replacement = this.state.update({ changes: { from: from, to: to, insert: expectedCloser }, filter: false }).state;
+        var deletion = this.state.update({ changes: { from: from, to: to, insert: '' }, filter: false }).state;
+        var replacementBalanceCost = this.delimiterBalanceCost(replacement.doc.toString());
+        var deletionBalanceCost = this.delimiterBalanceCost(deletion.doc.toString());
+        return deletionBalanceCost < replacementBalanceCost ? 'delete' : 'replace';
+    };
+    Parser.prototype.delimiterBalanceCost = function (text) {
+        var pairs = { '(': ')', '[': ']', '{': '}' };
+        var closingDelimiters = new Set(Object.values(pairs));
+        var stack = [];
+        var quote = '';
+        var escaped = false;
+        var inComment = false;
+        var errors = 0;
+        for (var index = 0; index < text.length; index += 1) {
+            if (Date.now() >= this.deadline)
+                return Number.POSITIVE_INFINITY;
+            var 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);
+    };
+    Parser.prototype.findStringNewlineRecovery = function (text, start, quote) {
+        var escaped = false;
+        var lineBreaks = [];
+        for (var index = start; index < text.length; index += 1) {
+            var char = text[index];
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === '\\') {
+                escaped = true;
+            }
+            else if (char === quote) {
+                return { end: index + 1, lineBreaks: lineBreaks };
+            }
+            else if (char === '\n') {
+                lineBreaks.push(index);
+            }
+        }
+        return null;
+    };
+    Parser.prototype.checkAST = function (node) {
+        if (!node || Date.now() >= this.deadline)
+            return;
+        if (!node.type.isError && !this.containsError(node)) {
+            switch (node.name) {
+                case 'Query':
+                    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;
+            }
+        }
+        var child = node.firstChild;
+        while (child) {
+            this.checkAST(child);
+            child = child.nextSibling;
+        }
+    };
+    Parser.prototype.checkDuplicateQueryClauses = function (query) {
+        var seen = new Set();
+        var child = query.firstChild;
+        while (child) {
+            if (child.name === 'QueryClause') {
+                var clause = child.firstChild;
+                if (clause) {
+                    var label = queryClauseLabels.get(clause.name);
+                    if (label) {
+                        if (seen.has(clause.name)) {
+                            this.pushSemanticDiagnostic(clause, "duplicate \"".concat(label, "\" clause"), "duplicate:".concat(query.from, ":").concat(clause.name));
+                        }
+                        else {
+                            seen.add(clause.name);
+                        }
+                    }
+                }
+            }
+            child = child.nextSibling;
+        }
+    };
+    Parser.prototype.checkDuplicateShowClauses = function (show) {
+        var seen = new Set();
+        var child = show.firstChild;
+        while (child) {
+            var label = queryClauseLabels.get(child.name);
+            if (label) {
+                if (seen.has(child.name)) {
+                    this.pushSemanticDiagnostic(child, "duplicate \"".concat(label, "\" clause"), "duplicate:".concat(show.from, ":").concat(child.name));
+                }
+                else {
+                    seen.add(child.name);
+                }
+            }
+            child = child.nextSibling;
+        }
+    };
+    Parser.prototype.checkIntegerClause = function (clause) {
+        var number = clause.getChild('Number');
+        if (!number)
+            return;
+        var value = this.numericValue(number);
+        if (value !== null && Number.isInteger(value) && value >= 0)
+            return;
+        var keyword = numericClauses.get(clause.name);
+        if (keyword)
+            this.pushSemanticDiagnostic(number, "integer expected after \"".concat(keyword, "\""), "integer:".concat(clause.from));
+    };
+    Parser.prototype.checkTimeRangeShape = function (range) {
+        var _a;
+        var raw = this.maskLineComments(this.nodeText(range));
+        var segments = this.splitTopLevelSegments(raw, ':');
+        var expressions = [];
+        var 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:".concat(range.from));
+            return;
+        }
+        if (segments.every(function (segment) { return raw.slice(segment.from, segment.to).trim().length === 0; })) {
+            this.pushSemanticDiagnostic(range, 'time range must contain at least one value', "time-shape:".concat(range.from));
+            return;
+        }
+        var _loop_15 = function (index) {
+            var segment = segments[index];
+            var absoluteFrom = range.from + segment.from;
+            var absoluteTo = range.from + segment.to;
+            var segmentExpressions = expressions.filter(function (expression) { return expression.from >= absoluteFrom && expression.to <= absoluteTo; });
+            var expressionCount = segmentExpressions.length;
+            var hasText = raw.slice(segment.from, segment.to).trim().length > 0;
+            if ((hasText && expressionCount !== 1) || (!hasText && expressionCount !== 0)) {
+                this_5.pushSemanticDiagnosticAt(absoluteFrom, absoluteTo, 'invalid value in time range', "time-shape:".concat(range.from));
+                return { value: void 0 };
+            }
+            if (segments.length > 1 && expressionCount === 1) {
+                var kind = (_a = segmentExpressions[0].firstChild) === null || _a === void 0 ? void 0 : _a.name;
+                if (index < 2 && kind !== 'Number' && kind !== 'Duration' && kind !== 'PresetExpr') {
+                    this_5.pushSemanticDiagnostic(segmentExpressions[0], 'time range boundary must be a timestamp, duration, or preset', "time-shape:".concat(range.from));
+                    return { value: void 0 };
+                }
+                if (index === 2 && kind !== 'Number' && kind !== 'Duration') {
+                    this_5.pushSemanticDiagnostic(segmentExpressions[0], 'time range interval must be a number or duration', "time-shape:".concat(range.from));
+                    return { value: void 0 };
+                }
+                if (index === 3 && kind !== 'RollupIdentifier' && kind !== 'RollupFunctionCall') {
+                    this_5.pushSemanticDiagnostic(segmentExpressions[0], 'time range rollup must be a supported rollup function', "time-shape:".concat(range.from));
+                    return { value: void 0 };
+                }
+            }
+        };
+        var this_5 = this;
+        for (var index = 0; index < segments.length; index += 1) {
+            var state_4 = _loop_15(index);
+            if (typeof state_4 === "object")
+                return state_4.value;
+        }
+    };
+    Parser.prototype.checkBareRollup = function (identifier) {
+        var _a;
+        if (((_a = identifier.parent) === null || _a === void 0 ? void 0 : _a.name) === 'RollupFunctionCall')
+            return;
+        var name = this.nodeText(identifier).toLowerCase();
+        if (name === 'ewma' || name === 'moving_average' || name === 'percentile') {
+            this.pushSemanticDiagnostic(identifier, "rollup function \"".concat(name, "\" requires arguments"), "rollup:".concat(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:".concat(identifier.from));
+        }
+    };
+    Parser.prototype.checkRollupFunctionCall = function (call) {
+        var identifier = call.getChild('RollupIdentifier');
+        var body = call.getChild('RollupFunctionCallBody');
+        if (!identifier || !body)
+            return;
+        var name = this.nodeText(identifier).toLowerCase();
+        var 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:".concat(identifier.from));
+            return;
+        }
+        if (name !== 'ewma' && name !== 'moving_average' && name !== 'percentile') {
+            this.pushSemanticDiagnostic(body, "rollup function \"".concat(name, "\" does not accept arguments in the time range"), "rollup:".concat(call.from));
+            return;
+        }
+        var 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:".concat(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:".concat(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:".concat(call.from));
+            }
+        }
+    };
+    Parser.prototype.checkFunctionCall = function (call) {
+        var identifier = call.getChild('FunctionIdentifier');
+        var body = call.getChild('FunctionCallBody');
+        if (!identifier || !body)
+            return;
+        var name = this.nodeText(identifier).toLowerCase();
+        var args = this.directChildren(body, 'ArgItem');
+        if (name === 'ewma') {
+            var 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:".concat(call.from));
+            }
+        }
+        else if (name === 'moving_average') {
+            var window_1 = args.length === 2 ? this.numericValue(args[1]) : null;
+            if (window_1 === null || !Number.isInteger(window_1) || window_1 < 1) {
+                this.pushSemanticDiagnostic(body, 'function "moving_average" expects a field and a positive integer window', "function:".concat(call.from));
+            }
+        }
+        else if (name === 'percentile') {
+            var 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:".concat(call.from));
+            }
+        }
+        else if (name === 'corr' && args.length !== 2) {
+            this.pushSemanticDiagnostic(body, 'function "corr" expects exactly two input fields', "function:".concat(call.from));
+        }
+        else if ((name === 'slope' || name === 'zscore' || name === 'mad_score' || name === 'change_score') && args.length !== 1) {
+            this.pushSemanticDiagnostic(body, "function \"".concat(name, "\" expects exactly one input field"), "function:".concat(call.from));
+        }
+        else if (/^p(?:50|75|90|95|99)$/.test(name) && args.length !== 1) {
+            this.pushSemanticDiagnostic(body, "function \"".concat(name, "\" expects exactly one input field"), "function:".concat(call.from));
+        }
+    };
+    Parser.prototype.checkOuterFunctionCall = function (call) {
+        var identifier = call.firstChild;
+        if (!identifier || identifier.name === 'FunctionIdentifier')
+            return;
+        var name = this.nodeText(identifier).toLowerCase();
+        var body = identifier.nextSibling;
+        if (!body)
+            return;
+        var numbers = this.directChildren(body, 'Number');
+        var 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 \"".concat(name, "\" expects a positive integer argument"), "outer-function:".concat(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:".concat(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:".concat(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:".concat(call.from));
+        }
+        else if (name === 'fill') {
+            var 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:".concat(call.from));
+            }
+        }
+    };
+    Parser.prototype.checkProjectionAlias = function (target) {
+        var _a;
+        var outerAlias = target.getChild('As');
+        var projection = target.getChild('Projection');
+        if (!outerAlias || !projection)
+            return;
+        var items = this.directChildren(projection, 'ProjectionItem');
+        if (items.length !== 1) {
+            this.pushSemanticDiagnostic(outerAlias, 'an alias after ")" requires exactly one projection item', "projection-alias:".concat(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:".concat(target.from));
+        }
+    };
+    Parser.prototype.checkFilterSubqueryOperator = function (subquery) {
+        var binary = this.findAncestor(subquery.parent, 'BinaryExpr');
+        if (!binary) {
+            this.pushSemanticDiagnostic(subquery, 'filter subquery requires "IN" or "NOT IN"', "filter-subquery:".concat(subquery.from));
+            return;
+        }
+        var operators = new Set([
+            'Pow',
+            'Mul',
+            'Div',
+            'Mod',
+            'Add',
+            'Sub',
+            'Eql',
+            'EqlSingle',
+            'Neq',
+            'Lte',
+            'Lss',
+            'Gte',
+            'Gtr',
+            'EqlRegex',
+            'NeqRegex',
+            'In',
+            'NotInSeq',
+            'And',
+            'Or',
+            'DAnd',
+            'DOr',
+        ]);
+        var operator = null;
+        var 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:".concat(subquery.from));
+        }
+    };
+    Parser.prototype.checkFieldName = function (field) {
+        if (field.getChild('JsonField'))
+            return;
+        var 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:".concat(field.from));
+        }
+    };
+    Parser.prototype.checkCaseFunction = function (identifier) {
+        if (this.nodeText(identifier).toLowerCase() === 'substr') {
+            this.pushSemanticDiagnostic(identifier, 'function "substr" is not supported inside CASE', "case-function:".concat(identifier.from));
+        }
+    };
+    Parser.prototype.checkCaseResults = function (caseExpr) {
+        var clause = caseExpr.firstChild;
+        while (clause) {
+            if (clause.name === 'CaseWhenClause' || clause.name === 'CaseElseClause') {
+                var values = this.directChildren(clause, 'CaseValue');
+                var result = values[values.length - 1];
+                if (result && this.nodeText(result).trim().toLowerCase() === 'end') {
+                    var message = clause.name === 'CaseWhenClause' ? 'CASE result expected after "THEN"' : 'CASE result expected after "ELSE"';
+                    this.pushSemanticDiagnostic(result, message, "case-result:".concat(result.from));
+                }
+            }
+            clause = clause.nextSibling;
+        }
+    };
+    Parser.prototype.checkShowFunctionRequirements = function (show) {
+        var identifier = show.getChild('ShowIdentifier');
+        var body = show.getChild('FunctionCallBody');
+        if (!identifier || !body)
+            return;
+        var name = this.nodeText(identifier).toLowerCase();
+        var bodyText = this.maskStringsAndLineComments(this.nodeText(body));
+        var hasKeyin = /\bkeyin\s*=/.test(bodyText.toLowerCase());
+        var hasFrom = /\bfrom\s*=/.test(bodyText.toLowerCase());
+        var filter = show.getChild('FilterClause');
+        var 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, "\"".concat(name, "\" requires the named argument \"keyin\""), "show:".concat(show.from, ":keyin"));
+        }
+        if (name.startsWith('show_series_count_by_') && !hasFrom && !hasSourceFilter) {
+            this.pushSemanticDiagnostic(identifier, "\"".concat(name, "\" requires \"from\" or an @__source__ filter"), "show:".concat(show.from, ":from"));
+        }
+    };
+    Parser.prototype.pushSemanticDiagnostic = function (node, message, group) {
+        this.pushSemanticDiagnosticAt(node.from, node.to, message, group);
+    };
+    Parser.prototype.pushSemanticDiagnosticAt = function (from, to, message, group) {
+        var _this = this;
+        var diagnostic = this.makeDiagnosticAt(from, Math.max(from + 1, to), message, group);
+        if (!this.diagnostics.some(function (existing) { return _this.isSameDiagnostic(existing, diagnostic); }))
+            this.appendDiagnostics([diagnostic]);
+    };
+    Parser.prototype.directChildren = function (node, name) {
+        var children = [];
+        var child = node.firstChild;
+        while (child) {
+            if (child.name === name)
+                children.push(child);
+            child = child.nextSibling;
+        }
+        return children;
+    };
+    Parser.prototype.numericValue = function (node) {
+        if (!node)
+            return null;
+        var number = node.name === 'Number' ? node : node.getChild('Number');
+        if (!number)
+            return null;
+        var sign = node.name !== 'Number' && node.getChild('Sub') ? -1 : 1;
+        var value = sign * Number(this.nodeText(number).replace(/_/g, ''));
+        return Number.isFinite(value) ? value : null;
+    };
+    Parser.prototype.splitTopLevelSegments = function (text, separator) {
+        var segments = [];
+        var from = 0;
+        var quote = '';
+        var escaped = false;
+        var depth = 0;
+        for (var index = 0; index < text.length; index += 1) {
+            var 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: from, to: index });
+                from = index + 1;
+            }
+        }
+        segments.push({ from: from, to: text.length });
+        return segments;
+    };
+    Parser.prototype.describeUnknownFunction = function (node) {
+        var contextNames = new Set(['ProjectionField', 'FilterClause', 'HavingClause', 'ByExpr']);
+        var context = node.parent;
+        while (context && !contextNames.has(context.name))
+            context = context.parent;
+        if (!context)
+            return null;
+        var text = this.maskStringsAndLineComments(this.nodeText(context));
+        var functionPattern = /\b([A-Za-z_][A-Za-z0-9_-]*)\s*\(/g;
+        var match = functionPattern.exec(text);
+        while (match) {
+            var name_1 = match[1];
+            var nameFrom = context.from + match.index;
+            if (!this.containsFunctionCallStartingAt(context, nameFrom)) {
+                return this.makeDiagnosticAt(nameFrom, nameFrom + name_1.length, "unknown function \"".concat(name_1, "\""), "unknown-function:".concat(context.from, ":").concat(nameFrom));
+            }
+            match = functionPattern.exec(text);
+        }
+        return null;
+    };
+    Parser.prototype.containsFunctionCallStartingAt = function (node, from) {
+        if ((node.name === 'FunctionCall' || node.name === 'CaseFunctionCall' || node.name === 'FieldCall') && node.from === from)
+            return true;
+        var child = node.firstChild;
+        while (child) {
+            if (child.from <= from && child.to >= from && this.containsFunctionCallStartingAt(child, from))
+                return true;
+            child = child.nextSibling;
+        }
+        return false;
     };
     return Parser;
 }());