sqlui 0.1.60 → 0.1.61

data/client/resources/sqlui.js

@@ -3056,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) {
@@ -5503,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)
@@ -7254,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)) {
@@ -9478,7 +9481,7 @@
        });
    }
    const baseTheme$1$3 = /*@__PURE__*/buildTheme("." + baseThemeID, {
-       "&.cm-editor": {
+       "&": {
            position: "relative !important",
            boxSizing: "border-box",
            "&.cm-focused": {
@@ -9762,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)
@@ -10826,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) {
@@ -11509,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;
@@ -11803,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,
@@ -11822,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)
@@ -13329,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);
@@ -13375,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();
                });
@@ -17128,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)
@@ -17139,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`
@@ -17150,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--;
                    }
                }
@@ -17453,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) {
@@ -17487,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")
@@ -17699,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);
        }
@@ -21995,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)
@@ -22014,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 {
@@ -22036,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;
@@ -22044,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) {
@@ -22058,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];
@@ -22079,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);
@@ -22104,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);
@@ -22149,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
@@ -22159,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);
            }
@@ -22171,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);
@@ -22189,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;
@@ -22206,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);
@@ -22224,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;
                }
            }
@@ -22239,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
@@ -22321,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
@@ -22332,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();
@@ -22383,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;
@@ -22607,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 {
@@ -22647,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;
@@ -22660,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;
            }
@@ -22689,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
@@ -22740,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())
@@ -22845,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++) {
@@ -22859,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);
@@ -22892,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) {
@@ -22904,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;
@@ -22913,7 +22984,7 @@
                    }
            }
            else {
-               token.value = 0 /* Err */;
+               token.value = 0 /* Term.Err */;
                token.end = this.stream.clipPos(start + 1);
            }
        }
@@ -22930,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;
                        }
@@ -22961,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) {
@@ -22972,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];
@@ -22994,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`.
@@ -23029,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]
@@ -23038,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)
@@ -23056,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);
                            }
@@ -23067,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++)
@@ -23107,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;) {
@@ -23124,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)
@@ -23166,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);
@@ -23183,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)
@@ -23243,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++)
@@ -23334,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);
                }
            }
@@ -23351,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;
@@ -23376,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);
@@ -23391,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.
@@ -23473,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;
        }
@@ -23504,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;
@@ -23829,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,
@@ -23943,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) {
@@ -23959,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)
@@ -24081,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";
@@ -24107,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);
@@ -24199,7 +24279,7 @@
      ]);
      const sqlConfig = {
        dialect: MySQL,
-       upperCaseKeywords: true,
+       upperCaseKeywords: false,
        schema: editorSchema,
        tables
      };
@@ -24336,7 +24416,7 @@
            }
          }),
          MySQL.language.data.of({
-           autocomplete: keywordCompletionSource(MySQL, true)
+           autocomplete: keywordCompletionSource(MySQL, false)
          })
        ]
      );
@@ -24615,7 +24695,7 @@
      }
    }
 
-   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    left: 60px;\n    top: 60px;\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% - 120px);\n}\n";
+   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);
 
@@ -24643,7 +24723,7 @@
      const titleElement = document.createElement('div');
      titleElement.classList.add(styles['popup-title']);
      titleElement.innerText = title;
-     wrapperElement.appendChild(titleElement);
+     contentElement.appendChild(titleElement);
 
      const preElement = document.createElement('pre');
      preElement.id = 'popup-pre';
@@ -24678,6 +24758,31 @@
      }
    });
 
+   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;
@@ -24808,6 +24913,11 @@
      });
 
      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) {
@@ -25073,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);
 
@@ -25085,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);
    }
@@ -25512,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';
 
@@ -25558,7 +25668,7 @@
 
    function registerTableCellPopup (tableElement) {
      const listener = (event) => {
-       if (event.which === 1 && event.detail === 2) {
+       if (event.which === 1 && event.metaKey) {
          let node = event.target;
          while (!['td', 'th', 'table'].includes(node.tagName.toLowerCase()) && node.parentNode) {
            node = node.parentNode;
@@ -25624,12 +25734,12 @@
    }
 
    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;
@@ -25818,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);