sqlui 0.1.59 → 0.1.61

data/client/resources/sqlui.js

@@ -1514,10 +1514,11 @@
        /**
        Create a selection range.
        */
-       static range(anchor, head, goalColumn) {
-           let goal = (goalColumn !== null && goalColumn !== void 0 ? goalColumn : 33554431 /* RangeFlag.NoGoalColumn */) << 5 /* RangeFlag.GoalColumnOffset */;
-           return head < anchor ? SelectionRange.create(head, anchor, 16 /* RangeFlag.Inverted */ | goal | 8 /* RangeFlag.AssocAfter */)
-               : SelectionRange.create(anchor, head, goal | (head > anchor ? 4 /* RangeFlag.AssocBefore */ : 0));
+       static range(anchor, head, goalColumn, bidiLevel) {
+           let flags = ((goalColumn !== null && goalColumn !== void 0 ? goalColumn : 33554431 /* RangeFlag.NoGoalColumn */) << 5 /* RangeFlag.GoalColumnOffset */) |
+               (bidiLevel == null ? 3 : Math.min(2, bidiLevel));
+           return head < anchor ? SelectionRange.create(head, anchor, 16 /* RangeFlag.Inverted */ | 8 /* RangeFlag.AssocAfter */ | flags)
+               : SelectionRange.create(anchor, head, (head > anchor ? 4 /* RangeFlag.AssocBefore */ : 0) | flags);
        }
        /**
        @internal
@@ -3055,7 +3056,7 @@
        @internal
        */
        static create(from, to, value) {
-           return new Range$1(from, to, value);
+           return new Range(from, to, value);
        }
    };
    function cmpRange(a, b) {
@@ -4346,6 +4347,26 @@
            }
        }
    }
+   function scrollableParent(dom) {
+       let doc = dom.ownerDocument;
+       for (let cur = dom.parentNode; cur;) {
+           if (cur == doc.body) {
+               break;
+           }
+           else if (cur.nodeType == 1) {
+               if (cur.scrollHeight > cur.clientHeight || cur.scrollWidth > cur.clientWidth)
+                   return cur;
+               cur = cur.assignedSlot || cur.parentNode;
+           }
+           else if (cur.nodeType == 11) {
+               cur = cur.host;
+           }
+           else {
+               break;
+           }
+       }
+       return null;
+   }
    class DOMSelectionState {
        constructor() {
            this.anchorNode = null;
@@ -5482,7 +5503,9 @@
            super(-200000000 /* Side.Line */, -200000000 /* Side.Line */, null, spec);
        }
        eq(other) {
-           return other instanceof LineDecoration && attrsEq(this.spec.attributes, other.spec.attributes);
+           return other instanceof LineDecoration &&
+               this.spec.class == other.spec.class &&
+               attrsEq(this.spec.attributes, other.spec.attributes);
        }
        range(from, to = from) {
            if (to != from)
@@ -7233,7 +7256,8 @@
                    closestRect = rect;
                    closestX = dx;
                    closestY = dy;
-                   closestOverlap = !dx || (dx > 0 ? i < rects.length - 1 : i > 0);
+                   let side = dy ? (y < rect.top ? -1 : 1) : dx ? (x < rect.left ? -1 : 1) : 0;
+                   closestOverlap = !side || (side > 0 ? i < rects.length - 1 : i > 0);
                }
                if (dx == 0) {
                    if (y > rect.bottom && (!aboveRect || aboveRect.bottom < rect.bottom)) {
@@ -7544,22 +7568,30 @@
            this.compositionFirstChange = null;
            this.compositionEndedAt = 0;
            this.mouseSelection = null;
+           let handleEvent = (handler, event) => {
+               if (this.ignoreDuringComposition(event))
+                   return;
+               if (event.type == "keydown" && this.keydown(view, event))
+                   return;
+               if (this.mustFlushObserver(event))
+                   view.observer.forceFlush();
+               if (this.runCustomHandlers(event.type, view, event))
+                   event.preventDefault();
+               else
+                   handler(view, event);
+           };
            for (let type in handlers) {
                let handler = handlers[type];
-               view.contentDOM.addEventListener(type, (event) => {
-                   if (!eventBelongsToEditor(view, event) || this.ignoreDuringComposition(event))
-                       return;
-                   if (type == "keydown" && this.keydown(view, event))
-                       return;
-                   if (this.mustFlushObserver(event))
-                       view.observer.forceFlush();
-                   if (this.runCustomHandlers(type, view, event))
-                       event.preventDefault();
-                   else
-                       handler(view, event);
+               view.contentDOM.addEventListener(type, event => {
+                   if (eventBelongsToEditor(view, event))
+                       handleEvent(handler, event);
                }, handlerOptions[type]);
                this.registeredEvents.push(type);
            }
+           view.scrollDOM.addEventListener("mousedown", (event) => {
+               if (event.target == view.scrollDOM)
+                   handleEvent(handlers.mousedown, event);
+           });
            if (browser.chrome && browser.chrome_version == 102) { // FIXME remove at some point
                // On Chrome 102, viewport updates somehow stop wheel-based
                // scrolling. Turning off pointer events during the scroll seems
@@ -7716,12 +7748,18 @@
    const EmacsyPendingKeys = "dthko";
    // Key codes for modifier keys
    const modifierCodes = [16, 17, 18, 20, 91, 92, 224, 225];
+   function dragScrollSpeed(dist) {
+       return dist * 0.7 + 8;
+   }
    class MouseSelection {
        constructor(view, startEvent, style, mustSelect) {
            this.view = view;
            this.style = style;
            this.mustSelect = mustSelect;
+           this.scrollSpeed = { x: 0, y: 0 };
+           this.scrolling = -1;
            this.lastEvent = startEvent;
+           this.scrollParent = scrollableParent(view.contentDOM);
            let doc = view.contentDOM.ownerDocument;
            doc.addEventListener("mousemove", this.move = this.move.bind(this));
            doc.addEventListener("mouseup", this.up = this.up.bind(this));
@@ -7737,11 +7775,24 @@
            }
        }
        move(event) {
+           var _a;
            if (event.buttons == 0)
                return this.destroy();
            if (this.dragging !== false)
                return;
            this.select(this.lastEvent = event);
+           let sx = 0, sy = 0;
+           let rect = ((_a = this.scrollParent) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect())
+               || { left: 0, top: 0, right: this.view.win.innerWidth, bottom: this.view.win.innerHeight };
+           if (event.clientX <= rect.left)
+               sx = -dragScrollSpeed(rect.left - event.clientX);
+           else if (event.clientX >= rect.right)
+               sx = dragScrollSpeed(event.clientX - rect.right);
+           if (event.clientY <= rect.top)
+               sy = -dragScrollSpeed(rect.top - event.clientY);
+           else if (event.clientY >= rect.bottom)
+               sy = dragScrollSpeed(event.clientY - rect.bottom);
+           this.setScrollSpeed(sx, sy);
        }
        up(event) {
            if (this.dragging == null)
@@ -7751,19 +7802,41 @@
            this.destroy();
        }
        destroy() {
+           this.setScrollSpeed(0, 0);
            let doc = this.view.contentDOM.ownerDocument;
            doc.removeEventListener("mousemove", this.move);
            doc.removeEventListener("mouseup", this.up);
            this.view.inputState.mouseSelection = null;
        }
+       setScrollSpeed(sx, sy) {
+           this.scrollSpeed = { x: sx, y: sy };
+           if (sx || sy) {
+               if (this.scrolling < 0)
+                   this.scrolling = setInterval(() => this.scroll(), 50);
+           }
+           else if (this.scrolling > -1) {
+               clearInterval(this.scrolling);
+               this.scrolling = -1;
+           }
+       }
+       scroll() {
+           if (this.scrollParent) {
+               this.scrollParent.scrollLeft += this.scrollSpeed.x;
+               this.scrollParent.scrollTop += this.scrollSpeed.y;
+           }
+           else {
+               this.view.win.scrollBy(this.scrollSpeed.x, this.scrollSpeed.y);
+           }
+           if (this.dragging === false)
+               this.select(this.lastEvent);
+       }
        select(event) {
            let selection = this.style.get(event, this.extend, this.multiple);
            if (this.mustSelect || !selection.eq(this.view.state.selection) ||
                selection.main.assoc != this.view.state.selection.main.assoc)
                this.view.dispatch({
                    selection,
-                   userEvent: "select.pointer",
-                   scrollIntoView: true
+                   userEvent: "select.pointer"
                });
            this.mustSelect = false;
        }
@@ -7954,23 +8027,15 @@
    function basicMouseSelection(view, event) {
        let start = queryPos(view, event), type = getClickType(event);
        let startSel = view.state.selection;
-       let last = start, lastEvent = event;
        return {
            update(update) {
                if (update.docChanged) {
                    start.pos = update.changes.mapPos(start.pos);
                    startSel = startSel.map(update.changes);
-                   lastEvent = null;
                }
            },
            get(event, extend, multiple) {
-               let cur;
-               if (lastEvent && event.clientX == lastEvent.clientX && event.clientY == lastEvent.clientY)
-                   cur = last;
-               else {
-                   cur = last = queryPos(view, event);
-                   lastEvent = event;
-               }
+               let cur = queryPos(view, event);
                let range = rangeForClick(view, cur.pos, cur.bias, type);
                if (start.pos != cur.pos && !extend) {
                    let startRange = rangeForClick(view, start.pos, start.bias, type);
@@ -9416,7 +9481,7 @@
        });
    }
    const baseTheme$1$3 = /*@__PURE__*/buildTheme("." + baseThemeID, {
-       "&.cm-editor": {
+       "&": {
            position: "relative !important",
            boxSizing: "border-box",
            "&.cm-focused": {
@@ -9700,7 +9765,7 @@
                    insert: Text.of(domChange.text.slice(diff.from, diff.toB).split(LineBreakPlaceholder)) };
            }
        }
-       else if (newSel && (!view.hasFocus || !view.state.facet(editable) || newSel.main.eq(sel))) {
+       else if (newSel && (!view.hasFocus && view.state.facet(editable) || newSel.main.eq(sel))) {
            newSel = null;
        }
        if (!change && !newSel)
@@ -10764,6 +10829,8 @@
            if (this.measureScheduled < 0)
                this.measureScheduled = this.win.requestAnimationFrame(() => this.measure());
            if (request) {
+               if (this.measureRequests.indexOf(request) > -1)
+                   return;
                if (request.key != null)
                    for (let i = 0; i < this.measureRequests.length; i++) {
                        if (this.measureRequests[i].key === request.key) {
@@ -11447,6 +11514,8 @@
            if (runFor(scopeObj[prefix + modifiers(name, event, !isChar)]))
                return true;
            if (isChar && (event.altKey || event.metaKey || event.ctrlKey) &&
+               // Ctrl-Alt may be used for AltGr on Windows
+               !(browser.windows && event.ctrlKey && event.altKey) &&
                (baseName = base[event.keyCode]) && baseName != name) {
                if (runFor(scopeObj[prefix + modifiers(baseName, event, true)]))
                    return true;
@@ -11741,7 +11810,7 @@
        ];
    }
    function configChanged(update) {
-       return update.startState.facet(selectionConfig) != update.startState.facet(selectionConfig);
+       return update.startState.facet(selectionConfig) != update.state.facet(selectionConfig);
    }
    const cursorLayer = /*@__PURE__*/layer({
        above: true,
@@ -11760,7 +11829,7 @@
            return cursors;
        },
        update(update, dom) {
-           if (update.transactions.some(tr => tr.scrollIntoView))
+           if (update.transactions.some(tr => tr.selection))
                dom.style.animationName = dom.style.animationName == "cm-blink" ? "cm-blink2" : "cm-blink";
            let confChange = configChanged(update);
            if (confChange)
@@ -13267,15 +13336,14 @@
        constructor(gutter, viewport, height) {
            this.gutter = gutter;
            this.height = height;
-           this.localMarkers = [];
            this.i = 0;
            this.cursor = RangeSet.iter(gutter.markers, viewport.from);
        }
        line(view, line, extraMarkers) {
-           if (this.localMarkers.length)
-               this.localMarkers = [];
-           advanceCursor(this.cursor, this.localMarkers, line.from);
-           let localMarkers = extraMarkers.length ? this.localMarkers.concat(extraMarkers) : this.localMarkers;
+           let localMarkers = [];
+           advanceCursor(this.cursor, localMarkers, line.from);
+           if (extraMarkers.length)
+               localMarkers = localMarkers.concat(extraMarkers);
            let forLine = this.gutter.config.lineMarker(view, line, localMarkers);
            if (forLine)
                localMarkers.unshift(forLine);
@@ -13313,7 +13381,17 @@
            this.dom.className = "cm-gutter" + (this.config.class ? " " + this.config.class : "");
            for (let prop in config.domEventHandlers) {
                this.dom.addEventListener(prop, (event) => {
-                   let line = view.lineBlockAtHeight(event.clientY - view.documentTop);
+                   let target = event.target, y;
+                   if (target != this.dom && this.dom.contains(target)) {
+                       while (target.parentNode != this.dom)
+                           target = target.parentNode;
+                       let rect = target.getBoundingClientRect();
+                       y = (rect.top + rect.bottom) / 2;
+                   }
+                   else {
+                       y = event.clientY;
+                   }
+                   let line = view.lineBlockAtHeight(y - view.documentTop);
                    if (config.domEventHandlers[prop](view, line, event))
                        event.preventDefault();
                });
@@ -16967,7 +17045,7 @@
    */
    const defaultHighlightStyle = /*@__PURE__*/HighlightStyle.define([
        { tag: tags.meta,
-           color: "#7a757a" },
+           color: "#404740" },
        { tag: tags.link,
            textDecoration: "underline" },
        { tag: tags.heading,
@@ -17066,6 +17144,15 @@
    function bracketMatching(config = {}) {
        return [bracketMatchingConfig.of(config), bracketMatchingUnique];
    }
+   /**
+   When larger syntax nodes, such as HTML tags, are marked as
+   opening/closing, it can be a bit messy to treat the whole node as
+   a matchable bracket. This node prop allows you to define, for such
+   a node, a ‘handle’—the part of the node that is highlighted, and
+   that the cursor must be on to activate highlighting in the first
+   place.
+   */
+   const bracketMatchingHandle = /*@__PURE__*/new NodeProp();
    function matchingNodes(node, dir, brackets) {
        let byProp = node.prop(dir < 0 ? NodeProp.openedBy : NodeProp.closedBy);
        if (byProp)
@@ -17077,6 +17164,10 @@
        }
        return null;
    }
+   function findHandle(node) {
+       let hasHandle = node.type.prop(bracketMatchingHandle);
+       return hasHandle ? hasHandle(node.node) : node;
+   }
    /**
    Find the matching bracket for the token at `pos`, scanning
    direction `dir`. Only the `brackets` and `maxScanDistance`
@@ -17088,30 +17179,36 @@
        let tree = syntaxTree(state), node = tree.resolveInner(pos, dir);
        for (let cur = node; cur; cur = cur.parent) {
            let matches = matchingNodes(cur.type, dir, brackets);
-           if (matches && cur.from < cur.to)
-               return matchMarkedBrackets(state, pos, dir, cur, matches, brackets);
+           if (matches && cur.from < cur.to) {
+               let handle = findHandle(cur);
+               if (handle && (dir > 0 ? pos >= handle.from && pos < handle.to : pos > handle.from && pos <= handle.to))
+                   return matchMarkedBrackets(state, pos, dir, cur, handle, matches, brackets);
+           }
        }
        return matchPlainBrackets(state, pos, dir, tree, node.type, maxScanDistance, brackets);
    }
-   function matchMarkedBrackets(_state, _pos, dir, token, matching, brackets) {
-       let parent = token.parent, firstToken = { from: token.from, to: token.to };
+   function matchMarkedBrackets(_state, _pos, dir, token, handle, matching, brackets) {
+       let parent = token.parent, firstToken = { from: handle.from, to: handle.to };
        let depth = 0, cursor = parent === null || parent === void 0 ? void 0 : parent.cursor();
        if (cursor && (dir < 0 ? cursor.childBefore(token.from) : cursor.childAfter(token.to)))
            do {
                if (dir < 0 ? cursor.to <= token.from : cursor.from >= token.to) {
                    if (depth == 0 && matching.indexOf(cursor.type.name) > -1 && cursor.from < cursor.to) {
-                       return { start: firstToken, end: { from: cursor.from, to: cursor.to }, matched: true };
+                       let endHandle = findHandle(cursor);
+                       return { start: firstToken, end: endHandle ? { from: endHandle.from, to: endHandle.to } : undefined, matched: true };
                    }
                    else if (matchingNodes(cursor.type, dir, brackets)) {
                        depth++;
                    }
                    else if (matchingNodes(cursor.type, -dir, brackets)) {
-                       if (depth == 0)
+                       if (depth == 0) {
+                           let endHandle = findHandle(cursor);
                            return {
                                start: firstToken,
-                               end: cursor.from == cursor.to ? undefined : { from: cursor.from, to: cursor.to },
+                               end: endHandle && endHandle.from < endHandle.to ? { from: endHandle.from, to: endHandle.to } : undefined,
                                matched: false
                            };
+                       }
                        depth--;
                    }
                }
@@ -17391,8 +17488,13 @@
        combine(configs) {
            return combineConfig(configs, {
                minDepth: 100,
-               newGroupDelay: 500
-           }, { minDepth: Math.max, newGroupDelay: Math.min });
+               newGroupDelay: 500,
+               joinToEvent: (_t, isAdjacent) => isAdjacent,
+           }, {
+               minDepth: Math.max,
+               newGroupDelay: Math.min,
+               joinToEvent: (a, b) => (tr, adj) => a(tr, adj) || b(tr, adj)
+           });
        }
    });
    function changeEnd(changes) {
@@ -17425,7 +17527,7 @@
            let event = HistEvent.fromTransaction(tr);
            let time = tr.annotation(Transaction.time), userEvent = tr.annotation(Transaction.userEvent);
            if (event)
-               state = state.addChanges(event, time, userEvent, config.newGroupDelay, config.minDepth);
+               state = state.addChanges(event, time, userEvent, config, tr);
            else if (tr.selection)
                state = state.addSelection(tr.startState.selection, time, userEvent, config.newGroupDelay);
            if (isolate == "full" || isolate == "after")
@@ -17637,19 +17739,19 @@
        isolate() {
            return this.prevTime ? new HistoryState(this.done, this.undone) : this;
        }
-       addChanges(event, time, userEvent, newGroupDelay, maxLen) {
+       addChanges(event, time, userEvent, config, tr) {
            let done = this.done, lastEvent = done[done.length - 1];
            if (lastEvent && lastEvent.changes && !lastEvent.changes.empty && event.changes &&
                (!userEvent || joinableUserEvent.test(userEvent)) &&
                ((!lastEvent.selectionsAfter.length &&
-                   time - this.prevTime < newGroupDelay &&
-                   isAdjacent(lastEvent.changes, event.changes)) ||
+                   time - this.prevTime < config.newGroupDelay &&
+                   config.joinToEvent(tr, isAdjacent(lastEvent.changes, event.changes))) ||
                    // For compose (but not compose.start) events, always join with previous event
                    userEvent == "input.type.compose")) {
-               done = updateBranch(done, done.length - 1, maxLen, new HistEvent(event.changes.compose(lastEvent.changes), conc(event.effects, lastEvent.effects), lastEvent.mapped, lastEvent.startSelection, none$1));
+               done = updateBranch(done, done.length - 1, config.minDepth, new HistEvent(event.changes.compose(lastEvent.changes), conc(event.effects, lastEvent.effects), lastEvent.mapped, lastEvent.startSelection, none$1));
            }
            else {
-               done = updateBranch(done, done.length, maxLen, event);
+               done = updateBranch(done, done.length, config.minDepth, event);
            }
            return new HistoryState(done, none$1, time, userEvent);
        }
@@ -17898,7 +18000,7 @@
    function extendSel(view, how) {
        let selection = updateSel(view.state.selection, range => {
            let head = how(range);
-           return EditorSelection.range(range.anchor, head.head, head.goalColumn);
+           return EditorSelection.range(range.anchor, head.head, head.goalColumn, head.bidiLevel || undefined);
        });
        if (selection.eq(view.state.selection))
            return false;
@@ -20091,6 +20193,7 @@
                closeOnBlur: true,
                maxRenderedOptions: 100,
                defaultKeymap: true,
+               tooltipClass: () => "",
                optionClass: () => "",
                aboveCursor: false,
                icons: true,
@@ -20101,6 +20204,7 @@
                defaultKeymap: (a, b) => a && b,
                closeOnBlur: (a, b) => a && b,
                icons: (a, b) => a && b,
+               tooltipClass: (a, b) => c => joinClass(a(c), b(c)),
                optionClass: (a, b) => c => joinClass(a(c), b(c)),
                addToOptions: (a, b) => a.concat(b)
            });
@@ -20179,14 +20283,17 @@
                key: this
            };
            this.space = null;
+           this.currentClass = "";
            let cState = view.state.field(stateField);
            let { options, selected } = cState.open;
            let config = view.state.facet(completionConfig);
            this.optionContent = optionContent(config);
            this.optionClass = config.optionClass;
+           this.tooltipClass = config.tooltipClass;
            this.range = rangeAroundSelected(options.length, selected, config.maxRenderedOptions);
            this.dom = document.createElement("div");
            this.dom.className = "cm-tooltip-autocomplete";
+           this.updateTooltipClass(view.state);
            this.dom.addEventListener("mousedown", (e) => {
                for (let dom = e.target, match; dom && dom != this.dom; dom = dom.parentNode) {
                    if (dom.nodeName == "LI" && (match = /-(\d+)$/.exec(dom.id)) && +match[1] < options.length) {
@@ -20207,12 +20314,25 @@
            var _a, _b, _c;
            let cState = update.state.field(this.stateField);
            let prevState = update.startState.field(this.stateField);
+           this.updateTooltipClass(update.state);
            if (cState != prevState) {
                this.updateSel();
                if (((_a = cState.open) === null || _a === void 0 ? void 0 : _a.disabled) != ((_b = prevState.open) === null || _b === void 0 ? void 0 : _b.disabled))
                    this.dom.classList.toggle("cm-tooltip-autocomplete-disabled", !!((_c = cState.open) === null || _c === void 0 ? void 0 : _c.disabled));
            }
        }
+       updateTooltipClass(state) {
+           let cls = this.tooltipClass(state);
+           if (cls != this.currentClass) {
+               for (let c of this.currentClass.split(" "))
+                   if (c)
+                       this.dom.classList.remove(c);
+               for (let c of cls.split(" "))
+                   if (c)
+                       this.dom.classList.add(c);
+               this.currentClass = cls;
+           }
+       }
        positioned(space) {
            this.space = space;
            if (this.info)
@@ -20473,13 +20593,13 @@
            if (active.length == this.active.length && active.every((a, i) => a == this.active[i]))
                active = this.active;
            let open = this.open;
+           if (open && tr.docChanged)
+               open = open.map(tr.changes);
            if (tr.selection || active.some(a => a.hasResult() && tr.changes.touchesRange(a.from, a.to)) ||
                !sameResults(active, this.active))
-               open = CompletionDialog.build(active, state, this.id, this.open, conf);
+               open = CompletionDialog.build(active, state, this.id, open, conf);
            else if (open && open.disabled && !active.some(a => a.state == 1 /* State.Pending */))
                open = null;
-           else if (open && tr.docChanged)
-               open = open.map(tr.changes);
            if (!open && active.every(a => a.state != 1 /* State.Pending */) && active.some(a => a.hasResult()))
                active = active.map(a => a.hasResult() ? new ActiveSource(a.source, 0 /* State.Inactive */) : a);
            for (let effect of tr.effects)
@@ -21915,7 +22035,8 @@
        // Apply a reduce action
        /// @internal
        reduce(action) {
-           let depth = action >> 19 /* ReduceDepthShift */, type = action & 65535 /* ValueMask */;
+           var _a;
+           let depth = action >> 19 /* Action.ReduceDepthShift */, type = action & 65535 /* Action.ValueMask */;
            let { parser } = this.p;
            let dPrec = parser.dynamicPrecedence(type);
            if (dPrec)
@@ -21934,15 +22055,29 @@
            // consume two extra frames (the dummy parent node for the skipped
            // expression and the state that we'll be staying in, which should
            // be moved to `this.state`).
-           let base = this.stack.length - ((depth - 1) * 3) - (action & 262144 /* StayFlag */ ? 6 : 0);
-           let start = this.stack[base - 2];
-           let bufferBase = this.stack[base - 1], count = this.bufferBase + this.buffer.length - bufferBase;
+           let base = this.stack.length - ((depth - 1) * 3) - (action & 262144 /* Action.StayFlag */ ? 6 : 0);
+           let start = base ? this.stack[base - 2] : this.p.ranges[0].from, size = this.reducePos - start;
+           // This is a kludge to try and detect overly deep left-associative
+           // trees, which will not increase the parse stack depth and thus
+           // won't be caught by the regular stack-depth limit check.
+           if (size >= 2000 /* Recover.MinBigReduction */ && !((_a = this.p.parser.nodeSet.types[type]) === null || _a === void 0 ? void 0 : _a.isAnonymous)) {
+               if (start == this.p.lastBigReductionStart) {
+                   this.p.bigReductionCount++;
+                   this.p.lastBigReductionSize = size;
+               }
+               else if (this.p.lastBigReductionSize < size) {
+                   this.p.bigReductionCount = 1;
+                   this.p.lastBigReductionStart = start;
+                   this.p.lastBigReductionSize = size;
+               }
+           }
+           let bufferBase = base ? this.stack[base - 1] : 0, count = this.bufferBase + this.buffer.length - bufferBase;
            // Store normal terms or `R -> R R` repeat reductions
-           if (type < parser.minRepeatTerm || (action & 131072 /* RepeatFlag */)) {
-               let pos = parser.stateFlag(this.state, 1 /* Skipped */) ? this.pos : this.reducePos;
+           if (type < parser.minRepeatTerm || (action & 131072 /* Action.RepeatFlag */)) {
+               let pos = parser.stateFlag(this.state, 1 /* StateFlag.Skipped */) ? this.pos : this.reducePos;
                this.storeNode(type, start, pos, count + 4, true);
            }
-           if (action & 262144 /* StayFlag */) {
+           if (action & 262144 /* Action.StayFlag */) {
                this.state = this.stack[base];
            }
            else {
@@ -21956,7 +22091,7 @@
        // Shift a value into the buffer
        /// @internal
        storeNode(term, start, end, size = 4, isReduce = false) {
-           if (term == 0 /* Err */ &&
+           if (term == 0 /* Term.Err */ &&
                (!this.stack.length || this.stack[this.stack.length - 1] < this.buffer.length + this.bufferBase)) {
                // Try to omit/merge adjacent error nodes
                let cur = this, top = this.buffer.length;
@@ -21964,7 +22099,7 @@
                    top = cur.bufferBase - cur.parent.bufferBase;
                    cur = cur.parent;
                }
-               if (top > 0 && cur.buffer[top - 4] == 0 /* Err */ && cur.buffer[top - 1] > -1) {
+               if (top > 0 && cur.buffer[top - 4] == 0 /* Term.Err */ && cur.buffer[top - 1] > -1) {
                    if (start == end)
                        return;
                    if (cur.buffer[top - 2] >= start) {
@@ -21978,7 +22113,7 @@
            }
            else { // There may be skipped nodes that have to be moved forward
                let index = this.buffer.length;
-               if (index > 0 && this.buffer[index - 4] != 0 /* Err */)
+               if (index > 0 && this.buffer[index - 4] != 0 /* Term.Err */)
                    while (index > 0 && this.buffer[index - 2] > end) {
                        // Move this record forward
                        this.buffer[index] = this.buffer[index - 4];
@@ -21999,14 +22134,14 @@
        /// @internal
        shift(action, next, nextEnd) {
            let start = this.pos;
-           if (action & 131072 /* GotoFlag */) {
-               this.pushState(action & 65535 /* ValueMask */, this.pos);
+           if (action & 131072 /* Action.GotoFlag */) {
+               this.pushState(action & 65535 /* Action.ValueMask */, this.pos);
            }
-           else if ((action & 262144 /* StayFlag */) == 0) { // Regular shift
+           else if ((action & 262144 /* Action.StayFlag */) == 0) { // Regular shift
                let nextState = action, { parser } = this.p;
                if (nextEnd > this.pos || next <= parser.maxNode) {
                    this.pos = nextEnd;
-                   if (!parser.stateFlag(nextState, 1 /* Skipped */))
+                   if (!parser.stateFlag(nextState, 1 /* StateFlag.Skipped */))
                        this.reducePos = nextEnd;
                }
                this.pushState(nextState, start);
@@ -22024,7 +22159,7 @@
        // Apply an action
        /// @internal
        apply(action, next, nextEnd) {
-           if (action & 65536 /* ReduceFlag */)
+           if (action & 65536 /* Action.ReduceFlag */)
                this.reduce(action);
            else
                this.shift(action, next, nextEnd);
@@ -22069,9 +22204,9 @@
            let isNode = next <= this.p.parser.maxNode;
            if (isNode)
                this.storeNode(next, this.pos, nextEnd, 4);
-           this.storeNode(0 /* Err */, this.pos, nextEnd, isNode ? 8 : 4);
+           this.storeNode(0 /* Term.Err */, this.pos, nextEnd, isNode ? 8 : 4);
            this.pos = this.reducePos = nextEnd;
-           this.score -= 190 /* Delete */;
+           this.score -= 190 /* Recover.Delete */;
        }
        /// Check if the given term would be able to be shifted (optionally
        /// after some reductions) on this stack. This can be useful for
@@ -22079,10 +22214,10 @@
        /// given token when it applies.
        canShift(term) {
            for (let sim = new SimulatedStack(this);;) {
-               let action = this.p.parser.stateSlot(sim.state, 4 /* DefaultReduce */) || this.p.parser.hasAction(sim.state, term);
+               let action = this.p.parser.stateSlot(sim.state, 4 /* ParseState.DefaultReduce */) || this.p.parser.hasAction(sim.state, term);
                if (action == 0)
                    return false;
-               if ((action & 65536 /* ReduceFlag */) == 0)
+               if ((action & 65536 /* Action.ReduceFlag */) == 0)
                    return true;
                sim.reduce(action);
            }
@@ -22091,17 +22226,17 @@
        // inserts some missing token or rule.
        /// @internal
        recoverByInsert(next) {
-           if (this.stack.length >= 300 /* MaxInsertStackDepth */)
+           if (this.stack.length >= 300 /* Recover.MaxInsertStackDepth */)
                return [];
            let nextStates = this.p.parser.nextStates(this.state);
-           if (nextStates.length > 4 /* MaxNext */ << 1 || this.stack.length >= 120 /* DampenInsertStackDepth */) {
+           if (nextStates.length > 4 /* Recover.MaxNext */ << 1 || this.stack.length >= 120 /* Recover.DampenInsertStackDepth */) {
                let best = [];
                for (let i = 0, s; i < nextStates.length; i += 2) {
                    if ((s = nextStates[i + 1]) != this.state && this.p.parser.hasAction(s, next))
                        best.push(nextStates[i], s);
                }
-               if (this.stack.length < 120 /* DampenInsertStackDepth */)
-                   for (let i = 0; best.length < 4 /* MaxNext */ << 1 && i < nextStates.length; i += 2) {
+               if (this.stack.length < 120 /* Recover.DampenInsertStackDepth */)
+                   for (let i = 0; best.length < 4 /* Recover.MaxNext */ << 1 && i < nextStates.length; i += 2) {
                        let s = nextStates[i + 1];
                        if (!best.some((v, i) => (i & 1) && v == s))
                            best.push(nextStates[i], s);
@@ -22109,15 +22244,15 @@
                nextStates = best;
            }
            let result = [];
-           for (let i = 0; i < nextStates.length && result.length < 4 /* MaxNext */; i += 2) {
+           for (let i = 0; i < nextStates.length && result.length < 4 /* Recover.MaxNext */; i += 2) {
                let s = nextStates[i + 1];
                if (s == this.state)
                    continue;
                let stack = this.split();
                stack.pushState(s, this.pos);
-               stack.storeNode(0 /* Err */, stack.pos, stack.pos, 4, true);
+               stack.storeNode(0 /* Term.Err */, stack.pos, stack.pos, 4, true);
                stack.shiftContext(nextStates[i], this.pos);
-               stack.score -= 200 /* Insert */;
+               stack.score -= 200 /* Recover.Insert */;
                result.push(stack);
            }
            return result;
@@ -22126,17 +22261,17 @@
        // be done.
        /// @internal
        forceReduce() {
-           let reduce = this.p.parser.stateSlot(this.state, 5 /* ForcedReduce */);
-           if ((reduce & 65536 /* ReduceFlag */) == 0)
+           let reduce = this.p.parser.stateSlot(this.state, 5 /* ParseState.ForcedReduce */);
+           if ((reduce & 65536 /* Action.ReduceFlag */) == 0)
                return false;
            let { parser } = this.p;
            if (!parser.validAction(this.state, reduce)) {
-               let depth = reduce >> 19 /* ReduceDepthShift */, term = reduce & 65535 /* ValueMask */;
+               let depth = reduce >> 19 /* Action.ReduceDepthShift */, term = reduce & 65535 /* Action.ValueMask */;
                let target = this.stack.length - depth * 3;
                if (target < 0 || parser.getGoto(this.stack[target], term, false) < 0)
                    return false;
-               this.storeNode(0 /* Err */, this.reducePos, this.reducePos, 4, true);
-               this.score -= 100 /* Reduce */;
+               this.storeNode(0 /* Term.Err */, this.reducePos, this.reducePos, 4, true);
+               this.score -= 100 /* Recover.Reduce */;
            }
            this.reducePos = this.pos;
            this.reduce(reduce);
@@ -22144,9 +22279,9 @@
        }
        /// @internal
        forceAll() {
-           while (!this.p.parser.stateFlag(this.state, 2 /* Accepting */)) {
+           while (!this.p.parser.stateFlag(this.state, 2 /* StateFlag.Accepting */)) {
                if (!this.forceReduce()) {
-                   this.storeNode(0 /* Err */, this.pos, this.pos, 4, true);
+                   this.storeNode(0 /* Term.Err */, this.pos, this.pos, 4, true);
                    break;
                }
            }
@@ -22159,8 +22294,8 @@
            if (this.stack.length != 3)
                return false;
            let { parser } = this.p;
-           return parser.data[parser.stateSlot(this.state, 1 /* Actions */)] == 65535 /* End */ &&
-               !parser.stateSlot(this.state, 4 /* DefaultReduce */);
+           return parser.data[parser.stateSlot(this.state, 1 /* ParseState.Actions */)] == 65535 /* Seq.End */ &&
+               !parser.stateSlot(this.state, 4 /* ParseState.DefaultReduce */);
        }
        /// Restart the stack (put it back in its start state). Only safe
        /// when this.stack.length == 3 (state is directly below the top
@@ -22241,6 +22376,7 @@
        Recover[Recover["MaxNext"] = 4] = "MaxNext";
        Recover[Recover["MaxInsertStackDepth"] = 300] = "MaxInsertStackDepth";
        Recover[Recover["DampenInsertStackDepth"] = 120] = "DampenInsertStackDepth";
+       Recover[Recover["MinBigReduction"] = 2000] = "MinBigReduction";
    })(Recover || (Recover = {}));
    // Used to cheaply run some reductions to scan ahead without mutating
    // an entire stack
@@ -22252,7 +22388,7 @@
            this.base = this.stack.length;
        }
        reduce(action) {
-           let term = action & 65535 /* ValueMask */, depth = action >> 19 /* ReduceDepthShift */;
+           let term = action & 65535 /* Action.ValueMask */, depth = action >> 19 /* Action.ReduceDepthShift */;
            if (depth == 0) {
                if (this.stack == this.start.stack)
                    this.stack = this.stack.slice();
@@ -22303,6 +22439,42 @@
        }
    }
 
+   // See lezer-generator/src/encode.ts for comments about the encoding
+   // used here
+   function decodeArray(input, Type = Uint16Array) {
+       if (typeof input != "string")
+           return input;
+       let array = null;
+       for (let pos = 0, out = 0; pos < input.length;) {
+           let value = 0;
+           for (;;) {
+               let next = input.charCodeAt(pos++), stop = false;
+               if (next == 126 /* Encode.BigValCode */) {
+                   value = 65535 /* Encode.BigVal */;
+                   break;
+               }
+               if (next >= 92 /* Encode.Gap2 */)
+                   next--;
+               if (next >= 34 /* Encode.Gap1 */)
+                   next--;
+               let digit = next - 32 /* Encode.Start */;
+               if (digit >= 46 /* Encode.Base */) {
+                   digit -= 46 /* Encode.Base */;
+                   stop = true;
+               }
+               value += digit;
+               if (stop)
+                   break;
+               value *= 46 /* Encode.Base */;
+           }
+           if (array)
+               array[out++] = value;
+           else
+               array = new Type(value);
+       }
+       return array;
+   }
+
    class CachedToken {
        constructor() {
            this.start = -1;
@@ -22527,9 +22699,13 @@
            this.data = data;
            this.id = id;
        }
-       token(input, stack) { readToken(this.data, input, stack, this.id); }
+       token(input, stack) {
+           let { parser } = stack.p;
+           readToken(this.data, input, stack, this.id, parser.data, parser.tokenPrecTable);
+       }
    }
    TokenGroup.prototype.contextual = TokenGroup.prototype.fallback = TokenGroup.prototype.extend = false;
+   TokenGroup.prototype.fallback = TokenGroup.prototype.extend = false;
    /// `@external tokens` declarations in the grammar should resolve to
    /// an instance of this class.
    class ExternalTokenizer {
@@ -22567,8 +22743,8 @@
    // This function interprets that data, running through a stream as
    // long as new states with the a matching group mask can be reached,
    // and updating `input.token` when it matches a token.
-   function readToken(data, input, stack, group) {
-       let state = 0, groupMask = 1 << group, { parser } = stack.p, { dialect } = parser;
+   function readToken(data, input, stack, group, precTable, precOffset) {
+       let state = 0, groupMask = 1 << group, { dialect } = stack.p.parser;
        scan: for (;;) {
            if ((groupMask & data[state]) == 0)
                break;
@@ -22580,14 +22756,15 @@
                if ((data[i + 1] & groupMask) > 0) {
                    let term = data[i];
                    if (dialect.allows(term) &&
-                       (input.token.value == -1 || input.token.value == term || parser.overrides(term, input.token.value))) {
+                       (input.token.value == -1 || input.token.value == term ||
+                           overrides(term, input.token.value, precTable, precOffset))) {
                        input.acceptToken(term);
                        break;
                    }
                }
            let next = input.next, low = 0, high = data[state + 2];
            // Special case for EOF
-           if (input.next < 0 && high > low && data[accEnd + high * 3 - 3] == 65535 /* End */ && data[accEnd + high * 3 - 3] == 65535 /* End */) {
+           if (input.next < 0 && high > low && data[accEnd + high * 3 - 3] == 65535 /* Seq.End */ && data[accEnd + high * 3 - 3] == 65535 /* Seq.End */) {
                state = data[accEnd + high * 3 - 1];
                continue scan;
            }
@@ -22609,41 +22786,15 @@
            break;
        }
    }
-
-   // See lezer-generator/src/encode.ts for comments about the encoding
-   // used here
-   function decodeArray(input, Type = Uint16Array) {
-       if (typeof input != "string")
-           return input;
-       let array = null;
-       for (let pos = 0, out = 0; pos < input.length;) {
-           let value = 0;
-           for (;;) {
-               let next = input.charCodeAt(pos++), stop = false;
-               if (next == 126 /* BigValCode */) {
-                   value = 65535 /* BigVal */;
-                   break;
-               }
-               if (next >= 92 /* Gap2 */)
-                   next--;
-               if (next >= 34 /* Gap1 */)
-                   next--;
-               let digit = next - 32 /* Start */;
-               if (digit >= 46 /* Base */) {
-                   digit -= 46 /* Base */;
-                   stop = true;
-               }
-               value += digit;
-               if (stop)
-                   break;
-               value *= 46 /* Base */;
-           }
-           if (array)
-               array[out++] = value;
-           else
-               array = new Type(value);
-       }
-       return array;
+   function findOffset(data, start, term) {
+       for (let i = start, next; (next = data[i]) != 65535 /* Seq.End */; i++)
+           if (next == term)
+               return i - start;
+       return -1;
+   }
+   function overrides(token, prev, tableData, tableOffset) {
+       let iPrev = findOffset(tableData, tableOffset, prev);
+       return iPrev < 0 || findOffset(tableData, tableOffset, token) < iPrev;
    }
 
    // Environment variable used to control console output
@@ -22660,8 +22811,8 @@
            if (!(side < 0 ? cursor.childBefore(pos) : cursor.childAfter(pos)))
                for (;;) {
                    if ((side < 0 ? cursor.to < pos : cursor.from > pos) && !cursor.type.isError)
-                       return side < 0 ? Math.max(0, Math.min(cursor.to - 1, pos - 25 /* Margin */))
-                           : Math.min(tree.length, Math.max(cursor.from + 1, pos + 25 /* Margin */));
+                       return side < 0 ? Math.max(0, Math.min(cursor.to - 1, pos - 25 /* Safety.Margin */))
+                           : Math.min(tree.length, Math.max(cursor.from + 1, pos + 25 /* Safety.Margin */));
                    if (side < 0 ? cursor.prevSibling() : cursor.nextSibling())
                        break;
                    if (!cursor.parent())
@@ -22765,7 +22916,7 @@
            let actionIndex = 0;
            let main = null;
            let { parser } = stack.p, { tokenizers } = parser;
-           let mask = parser.stateSlot(stack.state, 3 /* TokenizerMask */);
+           let mask = parser.stateSlot(stack.state, 3 /* ParseState.TokenizerMask */);
            let context = stack.curContext ? stack.curContext.hash : 0;
            let lookAhead = 0;
            for (let i = 0; i < tokenizers.length; i++) {
@@ -22779,9 +22930,9 @@
                    token.mask = mask;
                    token.context = context;
                }
-               if (token.lookAhead > token.end + 25 /* Margin */)
+               if (token.lookAhead > token.end + 25 /* Safety.Margin */)
                    lookAhead = Math.max(token.lookAhead, lookAhead);
-               if (token.value != 0 /* Err */) {
+               if (token.value != 0 /* Term.Err */) {
                    let startIndex = actionIndex;
                    if (token.extended > -1)
                        actionIndex = this.addActions(stack, token.extended, token.end, actionIndex);
@@ -22812,7 +22963,7 @@
            let main = new CachedToken, { pos, p } = stack;
            main.start = pos;
            main.end = Math.min(pos + 1, p.stream.end);
-           main.value = pos == p.stream.end ? p.parser.eofTerm : 0 /* Err */;
+           main.value = pos == p.stream.end ? p.parser.eofTerm : 0 /* Term.Err */;
            return main;
        }
        updateCachedToken(token, tokenizer, stack) {
@@ -22824,7 +22975,7 @@
                    if (parser.specialized[i] == token.value) {
                        let result = parser.specializers[i](this.stream.read(token.start, token.end), stack);
                        if (result >= 0 && stack.p.parser.dialect.allows(result >> 1)) {
-                           if ((result & 1) == 0 /* Specialize */)
+                           if ((result & 1) == 0 /* Specialize.Specialize */)
                                token.value = result >> 1;
                            else
                                token.extended = result >> 1;
@@ -22833,7 +22984,7 @@
                    }
            }
            else {
-               token.value = 0 /* Err */;
+               token.value = 0 /* Term.Err */;
                token.end = this.stream.clipPos(start + 1);
            }
        }
@@ -22850,13 +23001,13 @@
        addActions(stack, token, end, index) {
            let { state } = stack, { parser } = stack.p, { data } = parser;
            for (let set = 0; set < 2; set++) {
-               for (let i = parser.stateSlot(state, set ? 2 /* Skip */ : 1 /* Actions */);; i += 3) {
-                   if (data[i] == 65535 /* End */) {
-                       if (data[i + 1] == 1 /* Next */) {
+               for (let i = parser.stateSlot(state, set ? 2 /* ParseState.Skip */ : 1 /* ParseState.Actions */);; i += 3) {
+                   if (data[i] == 65535 /* Seq.End */) {
+                       if (data[i + 1] == 1 /* Seq.Next */) {
                            i = pair(data, i + 2);
                        }
                        else {
-                           if (index == 0 && data[i + 1] == 2 /* Other */)
+                           if (index == 0 && data[i + 1] == 2 /* Seq.Other */)
                                index = this.putAction(pair(data, i + 2), token, end, index);
                            break;
                        }
@@ -22881,6 +23032,11 @@
        // on recursive traversal.
        Rec[Rec["CutDepth"] = 15000] = "CutDepth";
        Rec[Rec["CutTo"] = 9000] = "CutTo";
+       Rec[Rec["MaxLeftAssociativeReductionCount"] = 300] = "MaxLeftAssociativeReductionCount";
+       // The maximum number of non-recovering stacks to explore (to avoid
+       // getting bogged down with exponentially multiplying stacks in
+       // ambiguous content)
+       Rec[Rec["MaxStackCount"] = 12] = "MaxStackCount";
    })(Rec || (Rec = {}));
    class Parse {
        constructor(parser, input, fragments, ranges) {
@@ -22892,6 +23048,9 @@
            this.minStackPos = 0;
            this.reused = [];
            this.stoppedAt = null;
+           this.lastBigReductionStart = -1;
+           this.lastBigReductionSize = 0;
+           this.bigReductionCount = 0;
            this.stream = new InputStream(input, ranges);
            this.tokens = new TokenCache(parser, this.stream);
            this.topTerm = parser.top[1];
@@ -22914,6 +23073,18 @@
            // This will hold stacks beyond `pos`.
            let newStacks = this.stacks = [];
            let stopped, stoppedTokens;
+           // If a large amount of reductions happened with the same start
+           // position, force the stack out of that production in order to
+           // avoid creating a tree too deep to recurse through.
+           // (This is an ugly kludge, because unfortunately there is no
+           // straightforward, cheap way to check for this happening, due to
+           // the history of reductions only being available in an
+           // expensive-to-access format in the stack buffers.)
+           if (this.bigReductionCount > 300 /* Rec.MaxLeftAssociativeReductionCount */ && stacks.length == 1) {
+               let [s] = stacks;
+               while (s.forceReduce() && s.stack.length && s.stack[s.stack.length - 2] >= this.lastBigReductionStart) { }
+               this.bigReductionCount = this.lastBigReductionSize = 0;
+           }
            // Keep advancing any stacks at `pos` until they either move
            // forward or can't be advanced. Gather stacks that can't be
            // advanced further in `stopped`.
@@ -22949,7 +23120,7 @@
                    throw new SyntaxError("No parse at " + pos);
                }
                if (!this.recovering)
-                   this.recovering = 5 /* Distance */;
+                   this.recovering = 5 /* Rec.Distance */;
            }
            if (this.recovering && stopped) {
                let finished = this.stoppedAt != null && stopped[0].pos > this.stoppedAt ? stopped[0]
@@ -22958,7 +23129,7 @@
                    return this.stackToTree(finished.forceAll());
            }
            if (this.recovering) {
-               let maxRemaining = this.recovering == 1 ? 1 : this.recovering * 3 /* MaxRemainingPerStep */;
+               let maxRemaining = this.recovering == 1 ? 1 : this.recovering * 3 /* Rec.MaxRemainingPerStep */;
                if (newStacks.length > maxRemaining) {
                    newStacks.sort((a, b) => b.score - a.score);
                    while (newStacks.length > maxRemaining)
@@ -22976,7 +23147,7 @@
                    for (let j = i + 1; j < newStacks.length; j++) {
                        let other = newStacks[j];
                        if (stack.sameState(other) ||
-                           stack.buffer.length > 500 /* MinBufferLengthPrune */ && other.buffer.length > 500 /* MinBufferLengthPrune */) {
+                           stack.buffer.length > 500 /* Rec.MinBufferLengthPrune */ && other.buffer.length > 500 /* Rec.MinBufferLengthPrune */) {
                            if (((stack.score - other.score) || (stack.buffer.length - other.buffer.length)) > 0) {
                                newStacks.splice(j--, 1);
                            }
@@ -22987,6 +23158,8 @@
                        }
                    }
                }
+               if (newStacks.length > 12 /* Rec.MaxStackCount */)
+                   newStacks.splice(12 /* Rec.MaxStackCount */, newStacks.length - 12 /* Rec.MaxStackCount */);
            }
            this.minStackPos = newStacks[0].pos;
            for (let i = 1; i < newStacks.length; i++)
@@ -23027,15 +23200,15 @@
                        break;
                }
            }
-           let defaultReduce = parser.stateSlot(stack.state, 4 /* DefaultReduce */);
+           let defaultReduce = parser.stateSlot(stack.state, 4 /* ParseState.DefaultReduce */);
            if (defaultReduce > 0) {
                stack.reduce(defaultReduce);
                if (verbose)
-                   console.log(base + this.stackID(stack) + ` (via always-reduce ${parser.getName(defaultReduce & 65535 /* ValueMask */)})`);
+                   console.log(base + this.stackID(stack) + ` (via always-reduce ${parser.getName(defaultReduce & 65535 /* Action.ValueMask */)})`);
                return true;
            }
-           if (stack.stack.length >= 15000 /* CutDepth */) {
-               while (stack.stack.length > 9000 /* CutTo */ && stack.forceReduce()) { }
+           if (stack.stack.length >= 15000 /* Rec.CutDepth */) {
+               while (stack.stack.length > 9000 /* Rec.CutTo */ && stack.forceReduce()) { }
            }
            let actions = this.tokens.getActions(stack);
            for (let i = 0; i < actions.length;) {
@@ -23044,8 +23217,8 @@
                let localStack = last ? stack : stack.split();
                localStack.apply(action, term, end);
                if (verbose)
-                   console.log(base + this.stackID(localStack) + ` (via ${(action & 65536 /* ReduceFlag */) == 0 ? "shift"
-                    : `reduce of ${parser.getName(action & 65535 /* ValueMask */)}`} for ${parser.getName(term)} @ ${start}${localStack == stack ? "" : ", split"})`);
+                   console.log(base + this.stackID(localStack) + ` (via ${(action & 65536 /* Action.ReduceFlag */) == 0 ? "shift"
+                    : `reduce of ${parser.getName(action & 65535 /* Action.ValueMask */)}`} for ${parser.getName(term)} @ ${start}${localStack == stack ? "" : ", split"})`);
                if (last)
                    return true;
                else if (localStack.pos > start)
@@ -23086,7 +23259,7 @@
                        continue;
                }
                let force = stack.split(), forceBase = base;
-               for (let j = 0; force.forceReduce() && j < 10 /* ForceReduceLimit */; j++) {
+               for (let j = 0; force.forceReduce() && j < 10 /* Rec.ForceReduceLimit */; j++) {
                    if (verbose)
                        console.log(forceBase + this.stackID(force) + " (via force-reduce)");
                    let done = this.advanceFully(force, newStacks);
@@ -23103,7 +23276,7 @@
                if (this.stream.end > stack.pos) {
                    if (tokenEnd == stack.pos) {
                        tokenEnd++;
-                       token = 0 /* Err */;
+                       token = 0 /* Term.Err */;
                    }
                    stack.recoverByDelete(token, tokenEnd);
                    if (verbose)
@@ -23163,8 +23336,8 @@
            super();
            /// @internal
            this.wrappers = [];
-           if (spec.version != 14 /* Version */)
-               throw new RangeError(`Parser version (${spec.version}) doesn't match runtime version (${14 /* Version */})`);
+           if (spec.version != 14 /* File.Version */)
+               throw new RangeError(`Parser version (${spec.version}) doesn't match runtime version (${14 /* File.Version */})`);
            let nodeNames = spec.nodeNames.split(" ");
            this.minRepeatTerm = nodeNames.length;
            for (let i = 0; i < spec.repeatNodeCount; i++)
@@ -23254,16 +23427,16 @@
        hasAction(state, terminal) {
            let data = this.data;
            for (let set = 0; set < 2; set++) {
-               for (let i = this.stateSlot(state, set ? 2 /* Skip */ : 1 /* Actions */), next;; i += 3) {
-                   if ((next = data[i]) == 65535 /* End */) {
-                       if (data[i + 1] == 1 /* Next */)
+               for (let i = this.stateSlot(state, set ? 2 /* ParseState.Skip */ : 1 /* ParseState.Actions */), next;; i += 3) {
+                   if ((next = data[i]) == 65535 /* Seq.End */) {
+                       if (data[i + 1] == 1 /* Seq.Next */)
                            next = data[i = pair(data, i + 2)];
-                       else if (data[i + 1] == 2 /* Other */)
+                       else if (data[i + 1] == 2 /* Seq.Other */)
                            return pair(data, i + 2);
                        else
                            break;
                    }
-                   if (next == terminal || next == 0 /* Err */)
+                   if (next == terminal || next == 0 /* Term.Err */)
                        return pair(data, i + 1);
                }
            }
@@ -23271,19 +23444,19 @@
        }
        /// @internal
        stateSlot(state, slot) {
-           return this.states[(state * 6 /* Size */) + slot];
+           return this.states[(state * 6 /* ParseState.Size */) + slot];
        }
        /// @internal
        stateFlag(state, flag) {
-           return (this.stateSlot(state, 0 /* Flags */) & flag) > 0;
+           return (this.stateSlot(state, 0 /* ParseState.Flags */) & flag) > 0;
        }
        /// @internal
        validAction(state, action) {
-           if (action == this.stateSlot(state, 4 /* DefaultReduce */))
+           if (action == this.stateSlot(state, 4 /* ParseState.DefaultReduce */))
                return true;
-           for (let i = this.stateSlot(state, 1 /* Actions */);; i += 3) {
-               if (this.data[i] == 65535 /* End */) {
-                   if (this.data[i + 1] == 1 /* Next */)
+           for (let i = this.stateSlot(state, 1 /* ParseState.Actions */);; i += 3) {
+               if (this.data[i] == 65535 /* Seq.End */) {
+                   if (this.data[i + 1] == 1 /* Seq.Next */)
                        i = pair(this.data, i + 2);
                    else
                        return false;
@@ -23296,14 +23469,14 @@
        /// goto jumps. @internal
        nextStates(state) {
            let result = [];
-           for (let i = this.stateSlot(state, 1 /* Actions */);; i += 3) {
-               if (this.data[i] == 65535 /* End */) {
-                   if (this.data[i + 1] == 1 /* Next */)
+           for (let i = this.stateSlot(state, 1 /* ParseState.Actions */);; i += 3) {
+               if (this.data[i] == 65535 /* Seq.End */) {
+                   if (this.data[i + 1] == 1 /* Seq.Next */)
                        i = pair(this.data, i + 2);
                    else
                        break;
                }
-               if ((this.data[i + 2] & (65536 /* ReduceFlag */ >> 16)) == 0) {
+               if ((this.data[i + 2] & (65536 /* Action.ReduceFlag */ >> 16)) == 0) {
                    let value = this.data[i + 1];
                    if (!result.some((v, i) => (i & 1) && v == value))
                        result.push(this.data[i], value);
@@ -23311,11 +23484,6 @@
            }
            return result;
        }
-       /// @internal
-       overrides(token, prev) {
-           let iPrev = findOffset(this.data, this.tokenPrecTable, prev);
-           return iPrev < 0 || findOffset(this.data, this.tokenPrecTable, token) < iPrev;
-       }
        /// Configure the parser. Returns a new parser instance that has the
        /// given settings modified. Settings not provided in `config` are
        /// kept from the original parser.
@@ -23393,30 +23561,24 @@
            let disabled = null;
            for (let i = 0; i < values.length; i++)
                if (!flags[i]) {
-                   for (let j = this.dialects[values[i]], id; (id = this.data[j++]) != 65535 /* End */;)
+                   for (let j = this.dialects[values[i]], id; (id = this.data[j++]) != 65535 /* Seq.End */;)
                        (disabled || (disabled = new Uint8Array(this.maxTerm + 1)))[id] = 1;
                }
            return new Dialect(dialect, flags, disabled);
        }
        /// Used by the output of the parser generator. Not available to
-       /// user code.
+       /// user code. @hide
        static deserialize(spec) {
            return new LRParser(spec);
        }
    }
    function pair(data, off) { return data[off] | (data[off + 1] << 16); }
-   function findOffset(data, start, term) {
-       for (let i = start, next; (next = data[i]) != 65535 /* End */; i++)
-           if (next == term)
-               return i - start;
-       return -1;
-   }
    function findFinished(stacks) {
        let best = null;
        for (let stack of stacks) {
            let stopped = stack.p.stoppedAt;
            if ((stack.pos == stack.p.stream.end || stopped != null && stack.pos > stopped) &&
-               stack.p.parser.stateFlag(stack.state, 2 /* Accepting */) &&
+               stack.p.parser.stateFlag(stack.state, 2 /* StateFlag.Accepting */) &&
                (!best || best.score < stack.score))
                best = stack;
        }
@@ -23424,7 +23586,7 @@
    }
    function getSpecializer(spec) {
        if (spec.external) {
-           let mask = spec.extend ? 1 /* Extend */ : 0 /* Specialize */;
+           let mask = spec.extend ? 1 /* Specialize.Extend */ : 0 /* Specialize.Specialize */;
            return (value, stack) => (spec.external(value, stack) << 1) | mask;
        }
        return spec.get;
@@ -23749,7 +23911,7 @@
      states: "%vQ]QQOOO#wQRO'#DSO$OQQO'#CwO%eQQO'#CxO%lQQO'#CyO%sQQO'#CzOOQQ'#DS'#DSOOQQ'#C}'#C}O'UQRO'#C{OOQQ'#Cv'#CvOOQQ'#C|'#C|Q]QQOOQOQQOOO'`QQO'#DOO(xQRO,59cO)PQQO,59cO)UQQO'#DSOOQQ,59d,59dO)cQQO,59dOOQQ,59e,59eO)jQQO,59eOOQQ,59f,59fO)qQQO,59fOOQQ-E6{-E6{OOQQ,59b,59bOOQQ-E6z-E6zOOQQ,59j,59jOOQQ-E6|-E6|O+VQRO1G.}O+^QQO,59cOOQQ1G/O1G/OOOQQ1G/P1G/POOQQ1G/Q1G/QP+kQQO'#C}O+rQQO1G.}O)PQQO,59cO,PQQO'#Cw",
      stateData: ",[~OtOSPOSQOS~ORUOSUOTUOUUOVROXSOZTO]XO^QO_UO`UOaPObPOcPOdUOeUOfUOgUOhUO~O^]ORvXSvXTvXUvXVvXXvXZvX]vX_vX`vXavXbvXcvXdvXevXfvXgvXhvX~OsvX~P!jOa_Ob_Oc_O~ORUOSUOTUOUUOVROXSOZTO^tO_UO`UOa`Ob`Oc`OdUOeUOfUOgUOhUO~OWaO~P$ZOYcO~P$ZO[eO~P$ZORUOSUOTUOUUOVROXSOZTO^QO_UO`UOaPObPOcPOdUOeUOfUOgUOhUO~O]hOsoX~P%zOajObjOcjO~O^]ORkaSkaTkaUkaVkaXkaZka]ka_ka`kaakabkackadkaekafkagkahka~Oska~P'kO^]O~OWvXYvX[vX~P!jOWnO~P$ZOYoO~P$ZO[pO~P$ZO^]ORkiSkiTkiUkiVkiXkiZki]ki_ki`kiakibkickidkiekifkigkihki~Oski~P)xOWkaYka[ka~P'kO]hO~P$ZOWkiYki[ki~P)xOasObsOcsO~O",
      goto: "#hwPPPPPPPPPPPPPPPPPPPPPPPPPPx||||!Y!^!d!xPPP#[TYOZeUORSTWZbdfqT[OZQZORiZSWOZQbRQdSQfTZgWbdfqQ^PWk^lmrQl_Qm`RrseVORSTWZbdfq",
-     nodeNames: "⚠ LineComment BlockComment String Number Bool Null ( ) [ ] { } ; . Operator Punctuation SpecialVar Identifier QuotedIdentifier Keyword Type Bits Bytes Builtin Script Statement CompositeIdentifier Parens Braces Brackets Statement",
+     nodeNames: "⚠ LineComment BlockComment String Number Bool Null ( ) { } [ ] ; . Operator Punctuation SpecialVar Identifier QuotedIdentifier Keyword Type Bits Bytes Builtin Script Statement CompositeIdentifier Parens Braces Brackets Statement",
      maxTerm: 38,
      skippedNodes: [0,1,2],
      repeatNodeCount: 3,
@@ -23863,7 +24025,7 @@
            return this.children ? Object.keys(this.children).filter(x => x).map(name => ({ label: name, type })) : [];
        }
    }
-   function completeFromSchema(schema, tables, defaultTableName, defaultSchemaName) {
+   function completeFromSchema(schema, tables, schemas, defaultTableName, defaultSchemaName) {
        let top = new CompletionLevel;
        let defaultSchema = top.child(defaultSchemaName || "");
        for (let table in schema) {
@@ -23879,7 +24041,7 @@
            if (!schema.list.length)
                schema.list = schema.childCompletions("type");
        }
-       top.list = defaultSchema.list.concat(top.childCompletions("type"));
+       top.list = defaultSchema.list.concat(schemas || top.childCompletions("type"));
        return (context) => {
            let { parents, from, quoted, empty, aliases } = sourceContext(context.state, context.pos);
            if (empty && !context.explicit)
@@ -24001,7 +24163,7 @@
    for the given configuration.
    */
    function schemaCompletionSource(config) {
-       return config.schema ? completeFromSchema(config.schema, config.tables, config.defaultTable, config.defaultSchema)
+       return config.schema ? completeFromSchema(config.schema, config.tables, config.schemas, config.defaultTable, config.defaultSchema)
            : () => null;
    }
    const MySQLKeywords = "accessible algorithm analyze asensitive authors auto_increment autocommit avg avg_row_length binlog btree cache catalog_name chain change changed checkpoint checksum class_origin client_statistics coalesce code collations columns comment committed completion concurrent consistent contains contributors convert database databases day_hour day_microsecond day_minute day_second delay_key_write delayed delimiter des_key_file dev_pop dev_samp deviance directory disable discard distinctrow div dual dumpfile enable enclosed ends engine engines enum errors escaped even event events every explain extended fast field fields flush force found_rows fulltext grants handler hash high_priority hosts hour_microsecond hour_minute hour_second ignore ignore_server_ids import index index_statistics infile innodb insensitive insert_method install invoker iterate keys kill linear lines list load lock logs low_priority master master_heartbeat_period master_ssl_verify_server_cert masters max max_rows maxvalue message_text middleint migrate min min_rows minute_microsecond minute_second mod mode modify mutex mysql_errno no_write_to_binlog offline offset one online optimize optionally outfile pack_keys parser partition partitions password phase plugin plugins prev processlist profile profiles purge query quick range read_write rebuild recover regexp relaylog remove rename reorganize repair repeatable replace require resume rlike row_format rtree schedule schema_name schemas second_microsecond security sensitive separator serializable server share show slave slow snapshot soname spatial sql_big_result sql_buffer_result sql_cache sql_calc_found_rows sql_no_cache sql_small_result ssl starting starts std stddev stddev_pop stddev_samp storage straight_join subclass_origin sum suspend table_name table_statistics tables tablespace terminated triggers truncate uncommitted uninstall unlock upgrade use use_frm user_resources user_statistics utc_date utc_time utc_timestamp variables views warnings xa xor year_month zerofill";
@@ -24027,9 +24189,7 @@
    function createEditor (parent, metadata, onSubmit, onShiftSubmit) {
      const fixedHeightEditor = EditorView.theme({
        '.cm-scroller': {
-         height: '200px',
-         overflow: 'auto',
-         resize: 'vertical'
+         overflow: 'auto'
        }
      });
      const schemas = Object.entries(metadata.schemas);
@@ -24119,7 +24279,7 @@
      ]);
      const sqlConfig = {
        dialect: MySQL,
-       upperCaseKeywords: true,
+       upperCaseKeywords: false,
        schema: editorSchema,
        tables
      };
@@ -24256,7 +24416,7 @@
            }
          }),
          MySQL.language.data.of({
-           autocomplete: keywordCompletionSource(MySQL, true)
+           autocomplete: keywordCompletionSource(MySQL, false)
          })
        ]
      );
@@ -24310,6 +24470,7 @@
    let drag = new Drag();
 
    document.addEventListener('mousedown', (event) => {
+     if (event.button !== 0) return
      if (!event.target.classList.contains('col-resizer')) return
 
      drag = new Drag();
@@ -24366,10 +24527,11 @@
    });
 
    class ResizeTable extends HTMLTableElement {
-     constructor (columns, rows, cellRenderer) {
+     constructor (columns, rows, headerRenderer, cellRenderer) {
        super();
 
        this.columns = columns;
+       this.headerRenderer = headerRenderer;
        this.cellRenderer = cellRenderer;
 
        this.style.tableLayout = 'auto';
@@ -24408,7 +24570,11 @@
            resizerElement.dataset.colId = colElement.dataset.colId;
            contentWrapperElement.appendChild(resizerElement);
 
-           nameElement.innerText = column;
+           if (headerRenderer) {
+             nameElement.appendChild(headerRenderer(headerElement, index, column));
+           } else {
+             nameElement.innerText = column;
+           }
          });
 
          headerTrElement.appendChild(document.createElement('th'));
@@ -24475,21 +24641,21 @@
        this.tbodyElement = tbodyElement;
 
        let highlight = false;
-       rows.forEach(function (row) {
+       rows.forEach(function (row, rowIndex) {
          const rowElement = document.createElement('tr');
          if (highlight) {
            rowElement.classList.add('highlighted-row');
          }
          highlight = !highlight;
          tbodyElement.appendChild(rowElement);
-         row.forEach(function (value, index) {
+         row.forEach(function (value, columnIndex) {
+           const cellElement = document.createElement('td');
            if (cellRenderer) {
-             cellRenderer(rowElement, index, value);
+             cellElement.appendChild(cellRenderer(cellElement, rowIndex, columnIndex, value));
            } else {
-             const cellElement = document.createElement('td');
              cellElement.innerText = value;
-             rowElement.appendChild(cellElement);
            }
+           rowElement.appendChild(cellElement);
          });
          rowElement.appendChild(document.createElement('td'));
        });
@@ -24502,6 +24668,121 @@
 
    customElements.define('resize-table', ResizeTable, { extends: 'table' });
 
+   function styleInject(css, ref) {
+     if ( ref === void 0 ) ref = {};
+     var insertAt = ref.insertAt;
+
+     if (!css || typeof document === 'undefined') { return; }
+
+     var head = document.head || document.getElementsByTagName('head')[0];
+     var style = document.createElement('style');
+     style.type = 'text/css';
+
+     if (insertAt === 'top') {
+       if (head.firstChild) {
+         head.insertBefore(style, head.firstChild);
+       } else {
+         head.appendChild(style);
+       }
+     } else {
+       head.appendChild(style);
+     }
+
+     if (style.styleSheet) {
+       style.styleSheet.cssText = css;
+     } else {
+       style.appendChild(document.createTextNode(css));
+     }
+   }
+
+   var css_248z = ".popup_popup-wrapper__huCTg {\n    position: absolute;\n    background: rgba(0, 0, 0, 0.3);\n    width: 100%;\n    height: 100%;\n    top: 0;\n    left: 0;\n    z-index: 2;\n}\n\n.popup_popup-content__iGYws {\n    position: absolute;\n    top: 50px;\n    left: 50px;\n    height: calc(100% - 100px);\n    width: calc(100% - 100px);\n    background: #fff;\n    border: 1px solid #888;\n}\n\n.popup_popup-pre__gF3-Q {\n    position: absolute;\n    top: 40px;\n    left: 0;\n    height: calc(100% - 112px);\n    width: calc(100% - 20px);\n    overflow: auto;\n    font-size: 18px;\n    border-top: 1px solid #ddd;\n    border-bottom: 1px solid #ddd;\n    margin: 0px;\n    padding: 10px;\n    background: #fff;\n    font-family: monospace;\n}\n\n.popup_popup-pre__gF3-Q:focus {\n    outline: none;\n}\n.popup_popup-close__3GBw3 {\n    position: absolute;\n    right: 20px;\n    bottom: 10px;\n    width: 100px;\n    height: 30px;\n    cursor: pointer;\n    font-family: Helvetica, sans-serif;\n    display: flex;\n    align-items: center;\n    justify-content: center;\n    font-size: 18px;\n    color: #333;\n    border: 1px solid #888;\n    background: #fff;\n}\n\n.popup_popup-close__3GBw3:active {\n    background-color: #e6e6e6;\n}\n\n.popup_popup-title__W2N2J {\n    position: absolute;\n    top: 10px;\n    left: 10px;\n    font-family: Helvetica, sans-serif;\n    font-size: 18px;\n    color: #333;\n    font-weight: bold;\n    white-space: nowrap;\n    text-overflow: ellipsis;\n    overflow: hidden;\n    width: calc(100% - 20px);\n}\n";
+   var styles = {"popup-wrapper":"popup_popup-wrapper__huCTg","popup-content":"popup_popup-content__iGYws","popup-pre":"popup_popup-pre__gF3-Q","popup-close":"popup_popup-close__3GBw3","popup-title":"popup_popup-title__W2N2J"};
+   styleInject(css_248z);
+
+   function createPopup (title, text) {
+     const wrapperElement = document.createElement('div');
+     wrapperElement.id = 'popup';
+     wrapperElement.classList.add(styles['popup-wrapper']);
+     document.body.appendChild(wrapperElement);
+
+     const contentElement = document.createElement('div');
+     contentElement.classList.add(styles['popup-content']);
+     wrapperElement.appendChild(contentElement);
+
+     const closeElement = document.createElement('input');
+     closeElement.id = 'popup-close';
+     closeElement.classList.add(styles['popup-close']);
+     closeElement.type = 'button';
+     closeElement.value = 'Close';
+     contentElement.appendChild(closeElement);
+
+     closeElement.addEventListener('click', (event) => {
+       document.body.removeChild(wrapperElement);
+     });
+
+     const titleElement = document.createElement('div');
+     titleElement.classList.add(styles['popup-title']);
+     titleElement.innerText = title;
+     contentElement.appendChild(titleElement);
+
+     const preElement = document.createElement('pre');
+     preElement.id = 'popup-pre';
+     preElement.classList.add(styles['popup-pre']);
+     contentElement.appendChild(preElement);
+     preElement.innerText = text;
+
+     wrapperElement.addEventListener('click', () => {
+       document.body.removeChild(wrapperElement);
+     });
+
+     contentElement.addEventListener('click', (event) => {
+       event.stopPropagation();
+     });
+
+     closeElement.focus();
+   }
+
+   document.addEventListener('keydown', (event) => {
+     if (event.code === 'Escape') {
+       const wrapperElement = document.getElementById('popup');
+       if (wrapperElement) {
+         event.preventDefault();
+         document.body.removeChild(wrapperElement);
+       }
+     } else if (event.code === 'Tab') {
+       const wrapperElement = document.getElementById('popup');
+       if (wrapperElement) {
+         event.preventDefault();
+         document.getElementById('popup-close').focus();
+       }
+     }
+   });
+
+   function createVerticalResizer (resizerElement, resizableElement, min, max) {
+     let startY = null;
+     let startHeight = null;
+
+     const moveListener = (event) => {
+       const y = event.clientY - startY;
+       const height = Math.min(max, Math.max(min, startHeight + y));
+       console.log(`y: ${y}, height: ${height}`);
+       resizableElement.style.height = `${height}px`;
+     };
+
+     resizerElement.addEventListener('mousedown', (event) => {
+       if (event.button !== 0) return
+       event.preventDefault();
+       startY = event.clientY;
+       startHeight = resizableElement.clientHeight;
+       document.addEventListener('mousemove', moveListener);
+     });
+
+     document.addEventListener('mouseup', (_) => {
+       startY = null;
+       document.removeEventListener('mousemove', moveListener);
+     });
+   }
+
    /* global google */
 
    const PAGE_SIZE = 100;
@@ -24630,7 +24911,13 @@
          dropdownContent.classList.remove('submit-dropdown-content-show');
        }
      });
+
      window.editorView = createEditor(parent, window.metadata, onSubmit, onShiftSubmit);
+     const cmScroller = document.getElementsByClassName('cm-scroller')[0];
+     cmScroller.style.height = '200px';
+
+     const editorResizer = document.getElementById('editor-resizer');
+     createVerticalResizer(editorResizer, cmScroller, 100, 500);
    }
 
    function addEventListener (elementOrSelector, type, func) {
@@ -24857,13 +25144,11 @@
            }
            rows.push(row);
          }
-         const cellRenderer = function (rowElement, _columnIndex, value) {
-           const cellElement = document.createElement('td');
+         const cellRenderer = function (cellElement, _rowIndex, _columnIndex, value) {
            cellElement.style.textAlign = (typeof value) === 'string' ? 'left' : 'right';
-           cellElement.innerText = value;
-           rowElement.appendChild(cellElement);
+           return document.createTextNode(value)
          };
-         columnsElement.appendChild(new ResizeTable(columns, rows, cellRenderer));
+         columnsElement.appendChild(new ResizeTable(columns, rows, null, cellRenderer));
        }
 
        const indexEntries = Object.entries(table.indexes);
@@ -24883,13 +25168,11 @@
              rows.push(row);
            }
          }
-         const cellRenderer = function (rowElement, _columnIndex, value) {
-           const cellElement = document.createElement('td');
+         const cellRenderer = function (cellElement, _rowIndex, _columnIndex, value) {
            cellElement.style.textAlign = (typeof value) === 'string' ? 'left' : 'right';
-           cellElement.innerText = value;
-           rowElement.appendChild(cellElement);
+           return document.createTextNode(value)
          };
-         indexesElement.appendChild(new ResizeTable(columns, rows, cellRenderer));
+         indexesElement.appendChild(new ResizeTable(columns, rows, null, cellRenderer));
        }
      });
      window.structureLoaded = true;
@@ -24900,7 +25183,7 @@
      document.getElementById('submit-box').style.display = 'flex';
      document.getElementById('graph-box').style.display = 'flex';
      document.getElementById('fetch-sql-box').style.display = 'none';
-     document.getElementById('cancel-button').style.display = 'none';
+     document.getElementById('cancel-button').style.visibility = 'hidden';
      updateDownloadButtons(window?.sqlFetch);
      maybeFetchResult(internal);
 
@@ -24912,7 +25195,7 @@
      document.getElementById('submit-box').style.display = 'flex';
      document.getElementById('result-box').style.display = 'flex';
      document.getElementById('fetch-sql-box').style.display = 'none';
-     document.getElementById('cancel-button').style.display = 'none';
+     document.getElementById('cancel-button').style.visibility = 'hidden';
      focus(getSelection());
      maybeFetchResult(internal);
    }
@@ -25130,6 +25413,9 @@
                }
              }
              displaySqlFetch(sqlFetch);
+           }).catch(function (error) {
+             setSqlFetchError(sqlFetch, error);
+             displaySqlFetch(sqlFetch);
            });
          } else {
            response.text().then((result) => {
@@ -25137,20 +25423,28 @@
              sqlFetch.errorMessage = 'failed to execute query';
              sqlFetch.errorDetails = result;
              displaySqlFetch(sqlFetch);
+           }).catch(function (error) {
+             setSqlFetchError(sqlFetch, error);
+             displaySqlFetch(sqlFetch);
            });
          }
        })
        .catch(function (error) {
-         if (sqlFetch.state === 'pending') {
-           sqlFetch.endedAt = window.performance.now();
-           sqlFetch.state = 'error';
-           sqlFetch.errorMessage = 'failed to execute query';
-           sqlFetch.errorDetails = error;
-         }
+         setSqlFetchError(sqlFetch, error);
          displaySqlFetch(sqlFetch);
        });
    }
 
+   function setSqlFetchError (sqlFetch, error) {
+     // Ignore the error unless pending since the error may be the result of aborting.
+     if (sqlFetch.state === 'pending') {
+       sqlFetch.endedAt = window.performance.now();
+       sqlFetch.state = 'error';
+       sqlFetch.errorMessage = 'failed to execute query';
+       sqlFetch.errorDetails = error;
+     }
+   }
+
    function parseSqlVariables (params) {
      return Object.fromEntries(
        Array.from(params).filter(([key]) => {
@@ -25272,10 +25566,17 @@
      return abbrElement
    };
 
-   const resultCellRenderer = function (rowElement, columnIndex, value) {
+   const resultCellRenderer = function (cellElement, rowIndex, columnIndex, value) {
      const column = window.sqlFetch.result.columns[columnIndex];
      const columnType = window.sqlFetch.result.column_types[columnIndex];
 
+     cellElement.dataset.column = columnIndex.toString();
+     cellElement.dataset.row = rowIndex.toString();
+
+     if (typeof value === 'string' && value.indexOf('\n') >= 0) {
+       value = value.replaceAll('\n', '¶');
+     }
+
      if (value && window.metadata.columns[column]?.links?.length > 0) {
        const linksElement = document.createElement('div');
        window.metadata.columns[column].links.forEach((link) => {
@@ -25292,17 +25593,22 @@
        wrapperElement.appendChild(linksElement);
        wrapperElement.appendChild(textElement);
 
-       const columnElement = document.createElement('td');
-       columnElement.appendChild(wrapperElement);
-       rowElement.appendChild(columnElement);
+       return wrapperElement
      } else {
-       const cellElement = document.createElement('td');
        cellElement.style.textAlign = columnType === 'string' ? 'left' : 'right';
-       cellElement.innerText = value;
-       rowElement.appendChild(cellElement);
+       return document.createTextNode(value)
      }
    };
 
+   function resultHeaderRenderer (headerElement, columnIndex, value) {
+     headerElement.dataset.column = columnIndex.toString();
+
+     if (typeof value === 'string' && value.indexOf('\n') >= 0) {
+       value = value.replaceAll('\n', '¶');
+     }
+     return document.createTextNode(value)
+   }
+
    function displaySqlFetchInResultTab (fetch) {
      if (fetch.state === 'pending' || fetch.spinner === 'always') {
        clearResultBox();
@@ -25316,7 +25622,7 @@
        return
      }
 
-     document.getElementById('cancel-button').style.display = 'none';
+     document.getElementById('cancel-button').style.visibility = 'hidden';
      document.getElementById('fetch-sql-box').style.display = 'none';
      document.getElementById('result-box').style.display = 'flex';
 
@@ -25352,13 +25658,45 @@
      } else {
        clearResultBox();
        const resultBoxElement = document.getElementById('result-box');
-       tableElement = new ResizeTable(fetch.result.columns, rows, resultCellRenderer);
+       tableElement = new ResizeTable(fetch.result.columns, rows, resultHeaderRenderer, resultCellRenderer);
        tableElement.id = 'result-table';
+       registerTableCellPopup(tableElement);
        resultBoxElement.appendChild(tableElement);
      }
      tableElement.setAttribute('data-page', fetch.page);
    }
 
+   function registerTableCellPopup (tableElement) {
+     const listener = (event) => {
+       if (event.which === 1 && event.metaKey) {
+         let node = event.target;
+         while (!['td', 'th', 'table'].includes(node.tagName.toLowerCase()) && node.parentNode) {
+           node = node.parentNode;
+         }
+         if (node.tagName.toLowerCase() === 'td') {
+           if (event.type === 'mousedown') {
+             const row = parseInt(node.dataset.row);
+             const column = parseInt(node.dataset.column);
+             const title = window.sqlFetch.result.columns[column].replaceAll('\n', '¶');
+             createPopup(title, window.sqlFetch.result.rows[row][column]);
+           }
+           event.preventDefault();
+         } else if (node.tagName.toLowerCase() === 'th') {
+           if (event.type === 'mousedown') {
+             const column = parseInt(node.dataset.column);
+             const value = window.sqlFetch.result.columns[column];
+             const title = value.replaceAll('\n', '¶');
+             createPopup(title, value);
+           }
+           event.preventDefault();
+         }
+       }
+     };
+     // We only open the popup on mouseup but we need to preventDefault on mousedown to avoid the clicked text from
+     // being highlighted.
+     addEventListener(tableElement, 'mouseup', listener);
+     addEventListener(tableElement, 'mousedown', listener);
+   }
    function disableDownloadButtons () {
      document.getElementById('submit-dropdown-button-download-csv').classList.add('disabled');
      document.getElementById('submit-dropdown-button-copy-csv').classList.add('disabled');
@@ -25389,24 +25727,19 @@
    }
 
    function displaySqlFetchError (message, details) {
-     let statusMessage = 'error: ' + message;
-     if (statusMessage.length > 90) {
-       statusMessage = statusMessage.substring(0, 90) + '…';
-     }
      if (details) {
-       console.log(`${message}\n${details}`);
-       statusMessage += ' (check console)';
+       console.log(details);
      }
-     setStatus(statusMessage);
+     setStatus(message);
    }
 
    function clearSpinner () {
-     document.getElementById('cancel-button').style.display = 'none';
+     document.getElementById('cancel-button').style.visibility = 'hidden';
      document.getElementById('fetch-sql-box').style.display = 'none';
    }
 
    function displaySpinner (fetch) {
-     document.getElementById('cancel-button').style.display = 'flex';
+     document.getElementById('cancel-button').style.visibility = 'visible';
      document.getElementById('fetch-sql-box').style.display = 'flex';
 
      const elapsed = window.performance.now() - fetch.startedAt;
@@ -25505,14 +25838,14 @@
      const elapsed = Math.round(100 * (sqlFetch.getDuration() / 1000.0)) / 100;
 
      let message;
-     if (result.total_rows === 1) {
-       message = `${result.total_rows} row (${elapsed}s)`;
+     if (result.rows.length === 1) {
+       message = `1 row returned after ${elapsed}s`;
      } else {
-       message = `${result.total_rows.toLocaleString()} rows (${elapsed}s)`;
+       message = `${result.rows.length.toLocaleString()} rows returned after ${elapsed}s`;
      }
 
      if (result.total_rows > result.rows.length) {
-       message += ` (truncated to ${result.rows.length.toLocaleString()})`;
+       message += ` (truncated from ${result.total_rows.toLocaleString()})`;
      }
      setStatus(message);
 
@@ -25595,7 +25928,7 @@
                document.getElementById('main-box').style.display = 'flex';
                document.getElementById('server-name').innerText = window.metadata.server;
                document.title = `SQLUI ${window.metadata.server}`;
-               document.getElementById('header-link').href = result.list_url_path;
+               document.getElementById('header-link').href = result.base_url_path;
                const queryElement = document.getElementById('query');
 
                init(queryElement, submitCurrent, submitAll);