codemirror-lang-raku 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,59 +1,97 @@
 import { ContextTracker, ExternalTokenizer, LRParser } from '@lezer/lr';
-import { Tree } from '@lezer/common';
-import { syntaxTree, LRLanguage, indentNodeProp, delimitedIndent, foldNodeProp, foldInside, LanguageSupport } from '@codemirror/language';
+import { NodeWeakMap, parseMixed } from '@lezer/common';
+import { syntaxTree, delimitedIndent, LRLanguage, indentNodeProp, foldNodeProp, foldInside, LanguageSupport } from '@codemirror/language';
 import { tags, styleTags } from '@lezer/highlight';
+import { Prec, EditorState } from '@codemirror/state';
 
 // This file was generated by lezer-generator. You probably shouldn't edit it.
-const BlockComment = 1,
-  Pod = 2,
-  Heredoc = 3,
-  methodDot = 4,
-  MethodName = 5,
-  declaredName = 172,
-  declaredMethodName = 173,
-  smiley = 174,
-  Version = 6,
-  regexBody = 7,
-  quoteContent = 175,
-  quoteNestOpen = 176,
-  quoteNestClose = 177,
-  quoteEnd = 178,
-  rawString = 179,
-  quoteStart = 180,
-  Regex = 8,
-  fatArrowKey = 181,
-  wordOperator = 9,
-  LineComment = 10,
-  DocComment = 11,
-  radixNumber = 13,
-  PackageName = 26,
-  RoutineName = 33,
-  methodRoutineName = 36,
-  RegexName = 41,
-  EnumName = 45,
-  SubsetName = 48,
-  ConstantName = 51,
-  VariableName = 53,
-  AttributeName = 54,
-  SpecialVariable = 55,
-  Identifier = 56,
-  TypeName = 57,
-  Number = 58,
-  StringLiteral = 59,
-  Interpolation = 61,
-  PairKey = 62,
-  self = 142,
-  True = 143,
-  False = 144,
-  Nil = 145,
-  Operator = 164;
+const smiley = 199,
+  noSmiley = 200,
+  BlockComment = 1,
+  podStart = 2,
+  podEnd = 201,
+  podEndDirective = 3,
+  podText = 202,
+  PodDirective = 4,
+  PodHeading = 5,
+  PodStrong = 6,
+  PodEmphasis = 7,
+  PodCode = 8,
+  PodLink = 9,
+  PodFormat = 10,
+  rawHeredoc = 11,
+  interpolatingHeredoc = 12,
+  heredocStart = 203,
+  methodDot = 13,
+  MethodName = 14,
+  declaredName = 204,
+  declaredMethodName = 205,
+  Version = 15,
+  regexStart = 206,
+  regexBodyEnd = 207,
+  regexLitOpen = 208,
+  regexLitClose = 209,
+  regexText = 210,
+  CharacterClass = 16,
+  Assertion = 17,
+  regexQuote = 18,
+  regexOperator = 19,
+  regexComment = 20,
+  regexBlockComment = 21,
+  regexCapture = 22,
+  quoteContent = 211,
+  quoteNestOpen = 212,
+  quoteNestClose = 213,
+  quoteEnd = 214,
+  rawString = 215,
+  quoteStart = 216,
+  interpolatingWordList = 23,
+  regexLiteral = 24,
+  transliteration = 25,
+  plainName = 217,
+  wordOperator = 26,
+  multiName = 218,
+  operatorVariable = 27,
+  LineComment = 28,
+  DocComment = 29,
+  Pod = 31,
+  radixNumber = 32,
+  PackageName = 45,
+  RoutineName = 52,
+  methodRoutineName = 55,
+  multiRoutineName = 56,
+  RegexName = 61,
+  regexBody = 63,
+  VariableName = 65,
+  AttributeName = 66,
+  SpecialVariable = 67,
+  EnumName = 71,
+  SubsetName = 74,
+  ConstantName = 77,
+  Identifier = 79,
+  TypeName = 80,
+  Number = 81,
+  quotedString = 82,
+  Interpolation = 83,
+  PairKey = 84,
+  multi = 95,
+  proto = 96,
+  only = 97,
+  self = 164,
+  True = 165,
+  False = 166,
+  Nil = 167,
+  Operator = 186,
+  Regex = 190,
+  Heredoc = 191,
+  StringLiteral = 192;
 
 // Opening bracket -> closing bracket, for the delimiters of quotes and
 // embedded comments. Raku accepts any Unicode bracket pair; this lists
 // the ones that are likely to be typed.
-const brackets = {};
+const brackets$1 = {};
 for (let pair of ["()", "[]", "{}", "<>", "«»", "「」", "『』", "（）", "［］", "｛｝", "【】", "〈〉", "《》", "〔〕"])
-    brackets[pair.charCodeAt(0)] = pair.charCodeAt(1);
+    brackets$1[pair.charCodeAt(0)] = pair.charCodeAt(1);
 function isAsciiLetter(ch) { return ch >= 97 /* Ch.a */ && ch <= 122 /* Ch.z */ || ch >= 65 /* Ch.A */ && ch <= 90 /* Ch.Z */; }
 function isDigit(ch) { return ch >= 48 /* Ch._0 */ && ch <= 57 /* Ch._9 */; }
 // The characters of the grammar's whitespace token.
@@ -118,39 +156,130 @@ function word(input, from, to) {
 class Quote {
     constructor(parent, open, close, count, 
     // How many nested opening delimiters are unclosed.
-    depth) {
+    depth, interpolates, 
+    // Whether a backslash that does not start an escape still
+    // takes the delimiter after it out of play: q:c[a \] b]
+    escapes) {
         this.parent = parent;
         this.open = open;
         this.close = close;
         this.count = count;
         this.depth = depth;
-        this.hash = ((parent ? parent.hash * 31 : 7) + open * 5 + count * 3 + depth) | 0;
+        this.interpolates = interpolates;
+        this.escapes = escapes;
+        let hash = parent ? parent.hash : 7;
+        for (let part of [open, count, depth, interpolates, escapes ? 1 : 0])
+            hash = (hash * 31 + part) | 0;
+        this.hash = hash;
+    }
+    withDepth(depth) {
+        return new Quote(this.parent, this.open, this.close, this.count, depth, this.interpolates, this.escapes);
+    }
+}
+const noHeredocs = [];
+// The quote that the text of a heredoc is read as. It has no
+// delimiters, and ends where the text does.
+const heredocQuote = new Quote(null, -1, -1, 1, 0, 63 /* Interpolate.All */, true);
+// The body of a regex declaration, or the inside of a regex literal,
+// that is being read piece by piece.
+class RegexBody {
+    constructor(// The body around the block of code that this one is in.
+    parent, 
+    // How many braces are open in a block of code in the
+    // regex. Zero in the regex itself.
+    braces, 
+    // For a regex literal, the position in the document of
+    // the delimiter that closes it. It is not part of the
+    // hash, which is to be the same before and after an edit
+    // that moves the literal.
+    literalEnd = -1) {
+        this.parent = parent;
+        this.braces = braces;
+        this.literalEnd = literalEnd;
+        this.hash = ((parent ? parent.hash * 31 : 0) + 7919 * (braces + 1) + (literalEnd < 0 ? 0 : 104729)) | 0;
+    }
+    withBraces(braces) { return new RegexBody(this.parent, braces, this.literalEnd); }
+}
+// A Pod block that is being read piece by piece.
+class PodBlock {
+    constructor(kind, 
+    // What follows `=begin`, which `=end` has to repeat.
+    name, 
+    // Whether it holds code, in which formatting codes are not read.
+    code) {
+        this.kind = kind;
+        this.name = name;
+        this.code = code;
+        let hash = 101 + kind * 7 + (code ? 3 : 0);
+        for (let i = 0; i < name.length; i++)
+            hash = (hash * 31 + name.charCodeAt(i)) | 0;
+        this.hash = hash;
     }
 }
 class Context {
-    constructor(mode, quote) {
+    constructor(mode, quote, 
+    // The heredocs that were opened on the current line, whose
+    // text starts on the next one.
+    heredocs, pod, 
+    // The body of a regex declaration that this is in.
+    regex, hash = -1) {
         this.mode = mode;
         this.quote = quote;
+        this.heredocs = heredocs;
+        this.pod = pod;
+        this.regex = regex;
+        if (hash < 0) {
+            hash = (quote ? quote.hash : 0) ^ (pod ? pod.hash : 0) ^ (regex ? regex.hash : 0);
+            for (let { terminator, interpolates } of heredocs) {
+                hash = (hash * 31 + (interpolates ? 19 : 17)) | 0;
+                for (let i = 0; i < terminator.length; i++)
+                    hash = (hash * 31 + terminator.charCodeAt(i)) | 0;
+            }
+            // Negative values stand for "not worked out yet".
+            hash &= 0x7fffffff;
+        }
+        this.hash = hash;
+    }
+    withMode(mode) {
+        return mode == this.mode ? this : new Context(mode, this.quote, this.heredocs, this.pod, this.regex, this.hash);
+    }
+    withHeredocs(heredocs) {
+        return heredocs == this.heredocs ? this : new Context(this.mode, this.quote, heredocs, this.pod, this.regex);
+    }
+    withQuote(mode, quote, heredocs = this.heredocs) {
+        return new Context(mode, quote, heredocs, this.pod, this.regex);
+    }
+    withPod(pod) { return new Context(this.mode, this.quote, this.heredocs, pod, this.regex); }
+    withRegex(regex) {
+        return new Context(this.mode, this.quote, this.heredocs, this.pod, regex);
     }
-    // An old node is only reused where this is the same as where it was
-    // made. The mode is left out: it changes with every token, which
-    // would rule out nearly all reuse, and `reuse` works it out again.
-    get hash() { return this.quote ? this.quote.hash : 0; }
-    withMode(mode) { return mode == this.mode ? this : new Context(mode, this.quote); }
 }
+// The nodes of a string: a quote, the token of a word list that
+// interpolates, and the tree of its inside, which takes the place of
+// that token.
+const stringTerms = new Set([quotedString, interpolatingWordList, StringLiteral]);
 // The mode after a token or a node, for those where the term settles
 // it. Shifting a token and reusing a node both look here, so that they
 // agree.
 const termModes = new Map();
-for (let term of [VariableName, AttributeName, SpecialVariable, Number, radixNumber, Version, MethodName,
-    PairKey, rawString, quoteEnd, StringLiteral, Regex, regexBody, self, True, False, Nil])
+for (let term of [VariableName, AttributeName, SpecialVariable, operatorVariable, Number, radixNumber, Version, MethodName,
+    PairKey, rawString, quoteEnd, ...stringTerms, regexLiteral, transliteration, regexBody,
+    // The tree of the inside of a regex literal, which takes the
+    // place of the literal's token in a node that is reused.
+    Regex, self, True, False, Nil,
+    // The pieces of a regex. What follows them is more of
+    // the regex, or the brace that closes it.
+    regexText, CharacterClass, Assertion, regexQuote, regexOperator, regexComment,
+    regexBlockComment, regexCapture])
     termModes.set(term, 1 /* Mode.AfterTerm */);
-for (let term of [Identifier, TypeName, smiley, declaredName, declaredMethodName, PackageName, RoutineName,
-    methodRoutineName, RegexName, EnumName, SubsetName, ConstantName])
+for (let term of [Identifier, TypeName, smiley, noSmiley, declaredName, declaredMethodName, PackageName, RoutineName,
+    methodRoutineName, multiName, multiRoutineName, RegexName, EnumName, SubsetName, ConstantName])
     termModes.set(term, 2 /* Mode.AfterName */);
 // The `}` of "{...}" in a string does not take a subscript.
 for (let term of [quoteContent, Interpolation])
     termModes.set(term, 0 /* Mode.Term */);
+for (let term of [multi, proto, only])
+    termModes.set(term, 4 /* Mode.AfterMulti */);
 // The mode after an operator, from its first three characters. `after`
 // is the mode before it.
 function modeAfterOperator(first, second, third, after) {
@@ -165,7 +294,8 @@ function modeAfterOperator(first, second, third, after) {
 }
 // The mode after a token that the terms file has no name for, from its
 // first character. Keywords and identifiers come through here alike;
-// an identifier gets its mode when the Identifier node is reduced.
+// an identifier gets its mode when the Identifier node is reduced,
+// from modeAfter, which also looks at how it is spelled.
 function modeAfterChar(first) {
     if (first == 41 /* Ch.ParenClose */ || first == 93 /* Ch.BracketClose */ || first == 36 /* Ch.Dollar */ || first == 64 /* Ch.At */)
         return 1 /* Mode.AfterTerm */;
@@ -174,9 +304,20 @@ function modeAfterChar(first) {
         return 2 /* Mode.AfterName */;
     return first == 125 /* Ch.BraceClose */ ? 3 /* Mode.AfterBlock */ : 0 /* Mode.Term */;
 }
+// The built-in names that stand for a value and take no arguments. The
+// constant `e` is left out: a routine or a variable of one's own is too
+// often named that.
+const termWords = /^(pi|π|tau|τ|now|time|rand)$/;
 // The mode after the token of the given term at the input's position.
 // `before` is the mode before it.
 function modeAfter(term, input, offset, before) {
+    // A term that takes no arguments is followed by an operator: pi /2
+    if (term == Identifier) {
+        let end = nameEnd(input, offset);
+        // Most names are longer than these, and are not looked at further.
+        if (end - offset <= 4 && termWords.test(word(input, offset, end)))
+            return 1 /* Mode.AfterTerm */;
+    }
     let mode = termModes.get(term);
     if (mode != null)
         return mode;
@@ -185,17 +326,159 @@ function modeAfter(term, input, offset, before) {
         return modeAfterOperator(first, input.peek(offset + 1), input.peek(offset + 2), before);
     return modeAfterChar(first);
 }
-const skippedTerms = new Set([LineComment, DocComment, BlockComment, Pod, Heredoc]);
+// The context at the start of a parse. The tokens that start the parse
+// of the inside of another token are only looked for while the context
+// is still this one, which spares asking the parser whether they can
+// be shifted at every other token.
+const startContext = new Context(0 /* Mode.Term */, null, noHeredocs, null, null);
+// The tokens of the text of a heredoc, and the tree of its inside,
+// which takes the place of the token of one that interpolates.
+const heredocTerms = new Set([rawHeredoc, interpolatingHeredoc, Heredoc]);
+const skippedTerms = new Set([LineComment, DocComment, BlockComment, ...heredocTerms, Pod, podStart, podEnd, podEndDirective,
+    podText, PodDirective, PodHeading, PodStrong, PodEmphasis, PodCode, PodLink, PodFormat]);
+// The heredoc that the quote at offset `at` opens, when it opens one.
+// Its terminator is what the quote holds: END for q:to/END/
+function heredocAt(input, at) {
+    let first = input.peek(at);
+    if (first != 113 /* Ch.q */ && first != 81 /* Ch.Q */)
+        return null;
+    let opening = readOpening(input, at);
+    if (!opening || !opening.heredoc)
+        return null;
+    let end = opening.start;
+    while (input.peek(end) != opening.close && input.peek(end) != 10 /* Ch.Newline */ && input.peek(end) >= 0)
+        end++;
+    // An empty one, as in the `q:to//` of a quote that is being typed,
+    // would end the heredoc at the next blank line.
+    let terminator = word(input, opening.start, end).trim();
+    return terminator ? { terminator, interpolates: opening.interpolates == 63 /* Interpolate.All */ } : null;
+}
+// `heredocs`, with the heredoc that the quote at offset `at` opens, if
+// it opens one.
+function withHeredocAt(heredocs, input, at) {
+    let heredoc = heredocAt(input, at);
+    return heredoc ? heredocs.concat(heredoc) : heredocs;
+}
+function hasNewline(input, from, to) {
+    for (let i = from; i < to; i++)
+        if (input.peek(i) == 10 /* Ch.Newline */)
+            return true;
+    return false;
+}
+// The heredocs that are open after a reused node, of which the input is
+// at the start. As when tokens are shifted, a line break between tokens
+// and the text of a heredoc close the ones before them.
+function heredocsAfter(node, input, before) {
+    // Most reused nodes are single tokens.
+    if (!node.children.length && !stringTerms.has(node.type.id) && !heredocTerms.has(node.type.id))
+        return before;
+    let cursor = node.cursor(), found = [], closedAt = -1;
+    // Goes over the node at the cursor from its end, and tells whether
+    // the heredocs before some point in it are closed.
+    function scan() {
+        let type = cursor.type.id, { from, to } = cursor;
+        if (heredocTerms.has(type)) {
+            closedAt = to;
+            return true;
+        }
+        let isString = stringTerms.has(type);
+        if (isString) {
+            let heredoc = heredocAt(input, from);
+            if (heredoc)
+                found.push({ pos: from, heredoc });
+        }
+        // The tree of the inside of a regex literal or of a word list. It
+        // was one token when it was shifted, which opens no heredoc.
+        if (type == Regex || type == StringLiteral)
+            return false;
+        if (!cursor.lastChild())
+            return false;
+        // Between the pieces of a string lies its text, not whitespace.
+        let gaps = !isString;
+        for (let gapEnd = to;;) {
+            if (gaps && hasNewline(input, cursor.to, gapEnd)) {
+                closedAt = gapEnd;
+                break;
+            }
+            if (scan())
+                break;
+            gapEnd = cursor.from;
+            if (!cursor.prevSibling()) {
+                if (gaps && hasNewline(input, from, gapEnd))
+                    closedAt = gapEnd;
+                break;
+            }
+        }
+        cursor.parent();
+        return closedAt >= 0;
+    }
+    scan();
+    if (!found.length && closedAt < 0)
+        return before;
+    let after = found.filter(opener => opener.pos >= closedAt).sort((a, b) => a.pos - b.pos).map(opener => opener.heredoc);
+    return closedAt < 0 ? before.concat(after) : after.length ? after : noHeredocs;
+}
+// The last token in `node` that says what the mode after it is: one
+// that is not a comment or Pod, which leave the mode as it was. A node
+// that settles the mode by itself counts as a token. Null when the
+// node holds nothing but comments.
+function lastToken$1(node) {
+    if (termModes.has(node.type.id) || !node.lastChild)
+        return skippedTerms.has(node.type.id) ? null : node;
+    for (let child = node.lastChild; child; child = child.prevSibling) {
+        let found = skippedTerms.has(child.type.id) ? null : lastToken$1(child);
+        if (found)
+            return found;
+    }
+    return null;
+}
 const trackContext = new ContextTracker({
-    start: new Context(0 /* Mode.Term */, null),
+    start: startContext,
     shift(context, term, _stack, input) {
+        if (term == rawHeredoc || term == interpolatingHeredoc)
+            return context.withHeredocs(noHeredocs);
+        // The text of a heredoc that interpolates is read by a parser of
+        // its own, as a quote without delimiters.
+        if (term == heredocStart)
+            return context.withQuote(0 /* Mode.Term */, heredocQuote);
+        if (term == podStart)
+            return context.withPod(readPodStart(input));
+        if (term == podEnd || term == podEndDirective)
+            return context.withPod(null);
         if (skippedTerms.has(term))
             return context;
+        let { regex } = context;
+        if (term == regexStart)
+            return context.withRegex(new RegexBody(regex, 0));
+        if (term == regexBodyEnd)
+            return context.withRegex(regex && regex.parent).withMode(termModes.get(regexBody));
+        // The inside of a regex literal is read by a parser of its own, of
+        // which these are the first and the last token. The closing
+        // delimiter is found the way termToken found it when it made the
+        // literal one token, so that the two agree on where the regex ends.
+        if (term == regexLitOpen) {
+            let opening = regexOpening(input), end = opening ? regexEnd(input, opening) : -1;
+            // Without one, which takes a parse that does not start from a
+            // literal, the regex runs to the end of what is parsed.
+            return context.withRegex(new RegexBody(null, 0, end < 0 ? Infinity : input.pos + end));
+        }
+        if (term == regexLitClose)
+            return context.withRegex(null);
+        // The braces of a block of code in a regex, and of the blocks in it.
+        // The tokens `{` and `}` have no term to go by.
+        if (regex && !termModes.has(term)) {
+            if (input.next == 123 /* Ch.BraceOpen */)
+                context = context.withRegex(regex.withBraces(regex.braces + 1));
+            else if (input.next == 125 /* Ch.BraceClose */ && regex.braces > 0)
+                context = context.withRegex(regex.withBraces(regex.braces - 1));
+        }
         switch (term) {
             case quoteStart: {
-                let opening = readOpening(input);
-                return opening ? new Context(0 /* Mode.Term */, new Quote(context.quote, opening.open, opening.close, opening.count, 0))
-                    : context;
+                let opening = wordListOpening(input, 0) || readOpening(input);
+                if (!opening)
+                    return context;
+                let quote = new Quote(context.quote, opening.open, opening.close, opening.count, 0, opening.interpolates, opening.escapes);
+                return context.withQuote(0 /* Mode.Term */, quote, withHeredocAt(context.heredocs, input, 0));
             }
             case quoteNestOpen:
             case quoteNestClose: {
@@ -203,53 +486,37 @@ const trackContext = new ContextTracker({
                 if (!quote)
                     return context;
                 let depth = quote.depth + (term == quoteNestOpen ? 1 : -1);
-                return new Context(0 /* Mode.Term */, new Quote(quote.parent, quote.open, quote.close, quote.count, depth));
+                return context.withQuote(0 /* Mode.Term */, quote.withDepth(depth));
             }
             case quoteEnd:
-                return new Context(1 /* Mode.AfterTerm */, context.quote && context.quote.parent);
+                return context.withQuote(1 /* Mode.AfterTerm */, context.quote && context.quote.parent);
         }
         // The whitespace token has no term to go by. It is the only token
-        // that starts with a space.
-        if (!termModes.has(term) && isSpace(input.next))
+        // that starts with a space. A line break in it leaves the heredocs
+        // that found no terminator behind.
+        if (!termModes.has(term) && isSpace(input.next)) {
+            if (!context.heredocs.length)
+                return context;
+            for (let pos = 0; isSpace(input.peek(pos)); pos++)
+                if (input.peek(pos) == 10 /* Ch.Newline */)
+                    return context.withHeredocs(noHeredocs);
             return context;
+        }
+        if (term == rawString)
+            context = context.withHeredocs(withHeredocAt(context.heredocs, input, 0));
         return context.withMode(modeAfter(term, input, 0, context.mode));
     },
-    reduce(context, term) {
-        return term == Identifier || term == Interpolation ? context.withMode(termModes.get(term)) : context;
+    reduce(context, term, _stack, input) {
+        // The input is at the start of the node that is reduced.
+        return term == Identifier || term == Interpolation ? context.withMode(modeAfter(term, input, 0, context.mode))
+            : context;
     },
     reuse(context, node, _stack, input) {
-        // Walk down to the last token, keeping its offset from the node's
-        // start, where the input is positioned. Stop at a node that settles
-        // the mode by itself.
-        let last = node, offset = 0;
-        while (last instanceof Tree && last.children.length && !termModes.has(last.type.id)) {
-            offset += last.positions[last.children.length - 1];
-            last = last.children[last.children.length - 1];
-        }
-        let term;
-        if (last instanceof Tree) {
-            term = last.type.id;
-        }
-        else {
-            // A buffer holds its nodes in pre-order, as type, start, end and
-            // the index after the node's last descendant.
-            let { buffer } = last, index = 0;
-            for (let from = 0, to = buffer.length;;) {
-                index = from;
-                while (buffer[index + 3] < to)
-                    index = buffer[index + 3];
-                from = index + 4;
-                to = buffer[index + 3];
-                if (from == to || termModes.has(buffer[index]))
-                    break;
-            }
-            term = buffer[index];
-            offset += buffer[index + 1];
-        }
-        if (skippedTerms.has(term))
-            return context;
+        context = context.withHeredocs(heredocsAfter(node, input, context.heredocs));
+        // The node's positions count from its start, where the input is.
+        let last = lastToken$1(node.topNode);
         // What comes before a trailing `++` in a reused node is a term.
-        return context.withMode(modeAfter(term, input, offset, 1 /* Mode.AfterTerm */));
+        return last ? context.withMode(modeAfter(last.type.id, input, last.from, 1 /* Mode.AfterTerm */)) : context;
     },
     hash: context => context.hash
 });
@@ -257,7 +524,7 @@ function context(stack) { return stack.context; }
 // Whether a token of `size` characters at the current position is where
 // a term starts, as opposed to an infix operator.
 function inTermPosition(input, mode, size) {
-    if (mode == 0 /* Mode.Term */)
+    if (mode == 0 /* Mode.Term */ || mode == 4 /* Mode.AfterMulti */)
         return true;
     if (mode == 1 /* Mode.AfterTerm */)
         return false;
@@ -270,21 +537,28 @@ function inTermPosition(input, mode, size) {
 // #`(( ... )), needs the same number of closing ones. Brackets of the
 // same kind nest. An unclosed comment runs to the end of the input.
 const blockComment = new ExternalTokenizer(input => {
-    if (input.next != 35 /* Ch.Hash */ || input.peek(1) != 96 /* Ch.Backtick */)
+    let end = embeddedCommentEnd(input, 0);
+    if (!end)
         return;
-    let open = input.peek(2), close = brackets[open];
-    if (close == null)
-        return;
-    let count = 1;
-    while (input.peek(2 + count) == open)
-        count++;
-    let end = rawEnd(input, 2 + count, { open, close, count, escapes: false });
     if (end < 0)
         skipToEnd(input);
     else
         input.advance(end);
     input.acceptToken(BlockComment);
 });
+// The offset after the embedded comment that starts at offset `at`.
+// Zero when none starts there, and -1 when it is not closed.
+function embeddedCommentEnd(input, at) {
+    if (input.peek(at) != 35 /* Ch.Hash */ || input.peek(at + 1) != 96 /* Ch.Backtick */)
+        return 0;
+    let open = input.peek(at + 2), close = brackets$1[open];
+    if (close == null)
+        return 0;
+    let count = 1;
+    while (input.peek(at + 2 + count) == open)
+        count++;
+    return rawEnd(input, at + 2 + count, { open, close, count, escapes: false });
+}
 function isBlank(ch) { return ch == 32 /* Ch.Space */ || ch == 9 /* Ch.Tab */ || ch == 13 /* Ch.Return */; }
 // The offset of the first character at or after `pos` that is not a blank.
 function blanksEnd(input, pos) {
@@ -292,6 +566,18 @@ function blanksEnd(input, pos) {
         pos++;
     return pos;
 }
+// How far a token looks over the whitespace after it, to see what
+// follows. A token must not look far past its end: see the note on
+// lookahead in AGENTS.md.
+const maxGap = 20;
+// The offset of the first character at or after `pos` that is not a
+// blank, or not whitespace when `lines` is set, going over at most
+// maxGap characters.
+function gapEnd(input, pos, lines = false) {
+    for (let end = pos + maxGap; pos < end && (lines ? isSpace : isBlank)(input.peek(pos));)
+        pos++;
+    return pos;
+}
 // Whether only blanks separate the current position from the start of its line.
 function atLineStart(input) {
     for (let i = -1;; i--) {
@@ -321,121 +607,263 @@ function skipBlanks(input) {
 // Skips blanks, and tells whether the rest of the line starts with `text`.
 function lineStartsWith(input, text) {
     skipBlanks(input);
+    return startsWith(input, 0, text);
+}
+// Whether the text from offset `pos` starts with `text`, as a whole name.
+function startsWith(input, pos, text) {
     for (let i = 0; i < text.length; i++)
-        if (input.peek(i) != text.charCodeAt(i))
+        if (input.peek(pos + i) != text.charCodeAt(i))
             return false;
-    return !continuesName(input, text.length);
+    return !continuesName(input, pos + text.length);
 }
 const podDirective = /^(begin|for|end|finish|head\d*|item\d*|para|code|input|output|defn|comment|table|pod|rakudoc|config|alias|nested|data|[A-Z]{2,})$/;
-// A Pod block, from its `=directive` at the start of a line.
-//   =begin name ... =end name   delimited, can hold blocks of other names
-//   =finish                     the rest of the file
-//   =for name, =head1, ...      up to the next blank line
-const podToken = new ExternalTokenizer(input => {
+const podCodeBlock = /^(code|input|output)$/;
+// The offset after the directive that starts at the current position,
+// as in `=begin` or `=head1`, or -1 when there is none.
+function podDirectiveEnd(input) {
     if (input.next != 61 /* Ch.Equals */ || !isAsciiLetter(input.peek(1)) || !atLineStart(input))
-        return;
+        return -1;
     let end = 1;
     while (isAsciiLetter(input.peek(end)) || isDigit(input.peek(end)))
         end++;
     let directive = word(input, 1, end);
     if (!podDirective.test(directive) || continuesName(input, end))
-        return;
+        return -1;
     // A semantic block such as =TITLE has to start in the first column.
     // An indented `=FOO + 1` continues an assignment.
     if (directive.charCodeAt(0) <= 90 /* Ch.Z */ && input.peek(-1) >= 0 && input.peek(-1) != 10 /* Ch.Newline */)
+        return -1;
+    return end;
+}
+// The offset after the name that goes with a directive which ends at
+// offset `end`: `=begin pod`, `=for comment`, `=end code`. The other
+// directives have none.
+function podNameEnd(input, end) {
+    if (!/^(begin|for|end)$/.test(word(input, 1, end)))
+        return end;
+    let name = nameEnd(input, blanksEnd(input, end));
+    return name < 0 ? end : name;
+}
+// The block that the directive at the current position starts.
+//   =begin name ... =end name   delimited, can hold blocks of other names
+//   =finish                     the rest of the file
+//   =for name, =head1, ...      up to the next blank line
+function readPodStart(input) {
+    let end = podDirectiveEnd(input), directive = word(input, 1, end);
+    if (directive == "finish")
+        return new PodBlock(2 /* PodKind.Finish */, "", false);
+    let nameStart = blanksEnd(input, end), name = word(input, nameStart, Math.max(nameStart, nameEnd(input, nameStart)));
+    if (directive == "begin")
+        return new PodBlock(0 /* PodKind.Delimited */, name, podCodeBlock.test(name));
+    return new PodBlock(1 /* PodKind.Paragraph */, "", podCodeBlock.test(directive == "for" ? name : directive));
+}
+// Whether the current position is right after a `=head` directive,
+// where the text of the heading starts.
+function atHeadingText(input) {
+    let pos = -1;
+    while (isDigit(input.peek(pos)))
+        pos--;
+    for (let i = 0; i < 5; i++)
+        if (input.peek(pos - i) != "=head".charCodeAt(4 - i))
+            return false;
+    for (pos -= 5; isBlank(input.peek(pos)); pos--) { }
+    return input.peek(pos) < 0 || input.peek(pos) == 10 /* Ch.Newline */;
+}
+// Whether a formatting code starts at offset `pos`: B<, C<<, L«
+function isFormattingCode(input, pos) {
+    let ch = input.peek(pos), after = input.peek(pos + 1), before = input.peek(pos - 1);
+    return ch >= 65 /* Ch.A */ && ch <= 90 /* Ch.Z */ && (after == 60 /* Ch.Less */ || after == 171 /* Ch.GuillemetOpen */) &&
+        !isAsciiLetter(before) && !isDigit(before);
+}
+// The offset after the formatting code at the current position. When
+// the code is not closed in its paragraph, this is the negated offset
+// of the end of the text that was gone over to find that out.
+function formattingCodeEnd(input) {
+    let open = input.peek(1), close = brackets$1[open], count = 1;
+    while (open == 60 /* Ch.Less */ && input.peek(1 + count) == open)
+        count++;
+    for (let pos = 1 + count, depth = 1;; pos++) {
+        let ch = input.peek(pos);
+        if (ch < 0)
+            return -pos;
+        if (ch == 10 /* Ch.Newline */) {
+            // A blank line or a directive ends the paragraph.
+            let next = blanksEnd(input, pos + 1), after = input.peek(next);
+            if (after < 0 || after == 10 /* Ch.Newline */ || after == 61 /* Ch.Equals */ && isAsciiLetter(input.peek(next + 1)))
+                return -pos;
+        }
+        else if (ch == close && repeats(input, pos, close, count)) {
+            pos += count - 1;
+            if (--depth == 0)
+                return pos + 1;
+        }
+        else if (ch == open && count == 1) {
+            // C<a < b> is not closed by the first `>` when another `<` came before it.
+            depth++;
+        }
+    }
+}
+const formattingTerms = { 66: PodStrong, 73: PodEmphasis, 67: PodCode, 76: PodLink };
+// The pieces of a Pod block, which starts with a `=directive` at the
+// start of a line. What it is, and with that where it ends, is kept in
+// the context.
+const podToken = new ExternalTokenizer((input, stack) => {
+    let { pod } = context(stack);
+    if (!pod) {
+        let end = podDirectiveEnd(input);
+        if (end > 0)
+            input.acceptToken(podStart, podNameEnd(input, end));
         return;
-    input.advance(end);
-    if (directive == "finish") {
-        skipToEnd(input);
     }
-    else if (directive == "begin") {
-        skipBlanks(input);
-        let name = word(input, 0, Math.max(0, nameEnd(input, 0)));
-        for (;;) {
-            skipLine(input);
-            if (input.next < 0)
-                break;
-            input.advance();
-            if (!lineStartsWith(input, "=end"))
-                continue;
-            input.advance(4);
-            if (lineStartsWith(input, name)) {
-                skipLine(input);
-                break;
-            }
-        }
+    let next = input.next;
+    if (next < 0)
+        return input.acceptToken(podEnd);
+    if (next == 10 /* Ch.Newline */ && pod.kind == 1 /* PodKind.Paragraph */) {
+        // Ends before a blank line or another directive.
+        let pos = blanksEnd(input, 1), ch = input.peek(pos);
+        if (ch == 10 /* Ch.Newline */ || ch < 0 || ch == 61 /* Ch.Equals */ && isAsciiLetter(input.peek(pos + 1)))
+            return input.acceptToken(podEnd);
     }
-    else {
-        for (;;) {
+    let directive = pod.kind == 0 /* PodKind.Delimited */ ? podDirectiveEnd(input) : -1;
+    if (directive > 0) {
+        if (directive == 4 && startsWith(input, 1, "end") && startsWith(input, blanksEnd(input, 4), pod.name)) {
             skipLine(input);
-            if (input.next < 0)
-                break;
-            // Stop before a blank line or another directive.
-            let i = blanksEnd(input, 1), ch = input.peek(i);
-            if (ch == 10 /* Ch.Newline */ || ch < 0 || ch == 61 /* Ch.Equals */ && isAsciiLetter(input.peek(i + 1)))
-                break;
-            input.advance();
+            return input.acceptToken(podEndDirective);
         }
+        return input.acceptToken(PodDirective, podNameEnd(input, directive));
     }
-    input.acceptToken(Pod);
+    if (atHeadingText(input) && !isLineEnd(input, 0)) {
+        skipLine(input);
+        return input.acceptToken(PodHeading);
+    }
+    if (!pod.code && isFormattingCode(input, 0)) {
+        let end = formattingCodeEnd(input);
+        if (end > 0)
+            return input.acceptToken(formattingTerms[next] || PodFormat, end);
+        // What looked like a code is text. The text that was gone over is
+        // made one token, so that no token has looked beyond its own end.
+        // A token that does keeps the tokens before it from being reused.
+        return input.acceptToken(podText, -end);
+    }
+    // Text, up to where one of the above may apply.
+    for (;;) {
+        input.advance();
+        let ch = input.next;
+        if (ch < 0 || ch == 10 /* Ch.Newline */ || !pod.code && isFormattingCode(input, 0))
+            break;
+        // A directive can only follow the blanks at the start of a line.
+        if (ch == 61 /* Ch.Equals */ && atLineStart(input))
+            break;
+    }
+    input.acceptToken(podText);
 });
 const quoteWords = {
     q: "raw", Q: "raw", qw: "raw", qww: "raw", qx: "raw", Qw: "raw", Qww: "raw", Qx: "raw",
     qq: "interpolating", qqw: "interpolating", qqww: "interpolating", qqx: "interpolating",
     rx: "regex", m: "regex", ms: "regex",
-    s: "substitution", ss: "substitution", S: "substitution", tr: "substitution", TR: "substitution"
+    s: "substitution", ss: "substitution", S: "substitution",
+    // Like a substitution, but its first part is not a regex.
+    tr: "transliteration", TR: "transliteration"
 };
+// The kinds of interpolation that the adverbs of a quote switch.
+const interpolationAdverbs = new Map([
+    ["c", 1 /* Interpolate.Closure */], ["closure", 1 /* Interpolate.Closure */],
+    ["s", 2 /* Interpolate.Scalar */], ["scalar", 2 /* Interpolate.Scalar */],
+    ["a", 4 /* Interpolate.Array */], ["array", 4 /* Interpolate.Array */],
+    ["h", 8 /* Interpolate.Hash */], ["hash", 8 /* Interpolate.Hash */],
+    ["f", 16 /* Interpolate.Function */], ["function", 16 /* Interpolate.Function */],
+    ["b", 32 /* Interpolate.Backslash */], ["backslash", 32 /* Interpolate.Backslash */],
+    ["qq", 63 /* Interpolate.All */], ["double", 63 /* Interpolate.All */]
+]);
+// The opening of a word list that interpolates, at offset `at`: << or «
+function wordListOpening(input, at) {
+    let open = input.peek(at), count = open == 60 /* Ch.Less */ ? 2 : 1;
+    if (open != 171 /* Ch.GuillemetOpen */ && !(open == 60 /* Ch.Less */ && input.peek(at + 1) == 60 /* Ch.Less */))
+        return null;
+    return { open, close: brackets$1[open], count, start: at + count, kind: "interpolating",
+        interpolates: 63 /* Interpolate.All */, escapes: true };
+}
+// The opening of a quote that starts with a quote character at offset `at`.
+function quoteCharOpening(open, close, at, interpolates, escapes = true) {
+    return { open, close, count: 1, start: at + 1, kind: interpolates ? "interpolating" : "raw", interpolates, escapes };
+}
 // The delimiters, other than brackets, that are accepted after a quote word.
 function isQuoteDelimiter(ch) {
     return ch == 47 /* Ch.Slash */ || ch == 33 /* Ch.Bang */ || ch == 124 /* Ch.Pipe */ || ch == 126 /* Ch.Tilde */ || ch == 94 /* Ch.Caret */ ||
         ch == 37 /* Ch.Percent */ || ch == 64 /* Ch.At */ || ch == 34 /* Ch.DoubleQuote */ || ch == 39 /* Ch.Apostrophe */;
 }
-// Reads the start of a quote at the current position: a quote character,
-// or a quote word (q, qq, m, s, ...) with its adverbs and its delimiter.
-function readOpening(input) {
-    let next = input.next;
+// Reads the start of a quote at offset `at`: a quote character, or a
+// quote word (q, qq, m, s, ...) with its adverbs and its delimiter.
+// The offsets in the result count from the current position.
+function readOpening(input, at = 0) {
+    let next = input.peek(at);
     if (next == 34 /* Ch.DoubleQuote */)
-        return { open: next, close: next, count: 1, start: 1, kind: "interpolating", escapes: true };
+        return quoteCharOpening(next, next, at, 63 /* Interpolate.All */);
     if (next == 39 /* Ch.Apostrophe */)
-        return { open: next, close: next, count: 1, start: 1, kind: "raw", escapes: true };
+        return quoteCharOpening(next, next, at, 0);
     if (next == 0x201c /* “ */)
-        return { open: next, close: 0x201d, count: 1, start: 1, kind: "interpolating", escapes: true };
+        return quoteCharOpening(next, 0x201d, at, 63 /* Interpolate.All */);
     if (next == 0x2018 /* ‘ */)
-        return { open: next, close: 0x2019, count: 1, start: 1, kind: "raw", escapes: true };
+        return quoteCharOpening(next, 0x2019, at, 0);
     if (next == 0x300c /* 「 */)
-        return { open: next, close: 0x300d, count: 1, start: 1, kind: "raw", escapes: false };
+        return quoteCharOpening(next, 0x300d, at, 0, false);
     if (!isAsciiLetter(next))
         return null;
-    let pos = 1;
+    let pos = at + 1;
     while (isAsciiLetter(input.peek(pos)))
         pos++;
-    if (pos > 4)
+    if (pos - at > 4)
         return null;
-    let name = word(input, 0, pos), kind = quoteWords[name];
+    let name = word(input, at, pos), kind = quoteWords[name];
     if (!kind)
         return null;
-    // Adverbs: :w, :to, :g, :x(2)
-    let adverbs = false;
+    // Adverbs: :w, :to, :g, :x(2). Those of a regex mean other things
+    // than those of a quote: m:s/a b/
+    let adverbs = false, heredoc = false, isQuote = kind == "raw" || kind == "interpolating";
+    let interpolates = kind == "interpolating" ? 63 /* Interpolate.All */ : 0;
+    // Whether a backslash escapes the delimiter, apart from the escapes
+    // of :b. That comes with q and its :q adverb: Q and qq:!b have none.
+    let escapes = isQuote ? kind == "raw" && next == 113 /* Ch.q */ : true;
     while (input.peek(pos) == 58 /* Ch.Colon */ && (isAsciiLetter(input.peek(pos + 1)) || input.peek(pos + 1) == 33 /* Ch.Bang */)) {
         adverbs = true;
+        let negated = input.peek(pos + 1) == 33 /* Ch.Bang */, adverbStart = pos + (negated ? 2 : 1);
         pos += 2;
         while (isAsciiLetter(input.peek(pos)) || isDigit(input.peek(pos)))
             pos++;
+        let adverb = word(input, adverbStart, pos);
+        // An argument that is False or 0 switches the adverb off: q:c(False)
         if (input.peek(pos) == 40 /* Ch.ParenOpen */) {
+            let argStart = pos + 1;
             while (input.peek(pos) != 41 /* Ch.ParenClose */) {
                 if (input.peek(pos) < 0 || input.peek(pos) == 10 /* Ch.Newline */)
                     return null;
                 pos++;
             }
+            if (/^\s*(False|0)\s*$/.test(word(input, argStart, pos)))
+                negated = true;
             pos++;
         }
+        if (isQuote) {
+            let bits = interpolationAdverbs.get(adverb);
+            if (bits != null)
+                interpolates = negated ? interpolates & ~bits : interpolates | bits;
+            else if (!negated && (adverb == "q" || adverb == "single"))
+                escapes = true;
+            else if (!negated && (adverb == "to" || adverb == "heredoc"))
+                heredoc = true;
+        }
     }
     if (!adverbs && continuesName(input, pos))
         return null;
-    // The delimiter has to follow directly. Raku also takes `q {...}`, but
-    // then `S { ... }` and `m ($x)` on a name that is not a quote word
-    // would turn into quotes.
-    let open = input.peek(pos), close = brackets[open];
+    // The delimiter follows directly, or, for q, qq and Q, after blanks
+    // on the same line: q {...}. Not for m, s and the others: `s { ... }`
+    // and `m ($x)` are more often calls of a routine of one's own.
+    if (isQuote && isBlank(input.peek(pos))) {
+        let bracket = gapEnd(input, pos);
+        if (brackets$1[input.peek(bracket)] != null && input.peek(bracket) != 40 /* Ch.ParenOpen */)
+            pos = bracket;
+    }
+    let open = input.peek(pos), close = brackets$1[open];
     if (close == null) {
         if (!isQuoteDelimiter(open))
             return null;
@@ -448,7 +876,11 @@ function readOpening(input) {
     if (close != open)
         while (input.peek(pos + count) == open)
             count++;
-    return { open, close, count, start: pos + count, kind, escapes: name.charCodeAt(0) != 81 /* Ch.Q */ };
+    if (isQuote)
+        kind = interpolates ? "interpolating" : "raw";
+    if (interpolates & 32 /* Interpolate.Backslash */)
+        escapes = true;
+    return { open, close, count, start: pos + count, kind, interpolates, escapes, heredoc };
 }
 // The offset after the delimiter that closes a quote whose content
 // starts at `pos`, or -1 when it is not closed.
@@ -491,7 +923,7 @@ function quotedEnd(input, pos) {
 // The offset of the delimiter that closes a regex whose content starts
 // at `pos`, or -1. Delimiters do not count inside quotes, character
 // classes, comments and code blocks.
-function regexEnd(input, pos, open, close, count) {
+function regexEnd(input, { start: pos, open, close, count }) {
     for (let depth = 1;;) {
         let ch = input.peek(pos);
         if (ch < 0)
@@ -539,13 +971,20 @@ function regexEnd(input, pos, open, close, count) {
                     break;
                 pos = more;
             }
+            // The bracket that closes the class is not one of the regex: rx[ <[a]> ]
+            pos++;
         }
         else if (ch == 35 /* Ch.Hash */) {
-            while (input.peek(pos) >= 0 && input.peek(pos) != 10 /* Ch.Newline */)
-                pos++;
+            // An embedded comment, or one that runs to the end of the line.
+            let end = embeddedCommentEnd(input, pos);
+            if (end > 0)
+                pos = end;
+            else
+                while (input.peek(pos) >= 0 && input.peek(pos) != 10 /* Ch.Newline */)
+                    pos++;
         }
         else if (ch == 123 /* Ch.BraceOpen */ && close != 125 /* Ch.BraceClose */) {
-            let end = regexEnd(input, pos + 1, 123 /* Ch.BraceOpen */, 125 /* Ch.BraceClose */, 1);
+            let end = regexEnd(input, { start: pos + 1, open: 123 /* Ch.BraceOpen */, close: 125 /* Ch.BraceClose */, count: 1 });
             pos = end < 0 ? pos + 1 : end + 1;
         }
         else {
@@ -555,25 +994,41 @@ function regexEnd(input, pos, open, close, count) {
 }
 // The offset after a regex or substitution, given its opening, or -1.
 function regexTokenEnd(input, opening) {
-    let { open, close, count } = opening;
-    let end = regexEnd(input, opening.start, open, close, count);
+    let end = regexEnd(input, opening);
     if (end < 0)
         return -1;
-    end += count;
+    end += opening.count;
     // s/a/b/ has a second part. s{a} = 'b' does not.
-    if (opening.kind == "substitution" && open == close)
+    if (opening.kind != "regex" && opening.open == opening.close)
         end = rawEnd(input, end, opening);
     return end;
 }
+// The opening of a bare regex: /a/
+const slashOpening = { open: 47 /* Ch.Slash */, close: 47 /* Ch.Slash */, count: 1, start: 1, kind: "regex",
+    interpolates: 0, escapes: true };
+// The opening of the regex literal at the current position. The token
+// that makes a literal one token, and the parse of its inside, both
+// find its closing delimiter from this, so that they agree.
+function regexOpening(input) {
+    if (input.next == 47 /* Ch.Slash */)
+        return slashOpening;
+    let opening = readOpening(input);
+    return opening && (opening.kind == "regex" || opening.kind == "substitution") ? opening : null;
+}
 // The offset after a word list that opens at the current position, or
 // -1. A list that spans lines has to hold plain words, so that a stray
 // `<` does not swallow the code up to some later `>`. `strict` is for
 // a subscript, which has to be on one line, and cannot hold what
 // would make it a comparison: `$a<5 && $b>3`.
+//
+// A list with double angles is rarely a stray operator, and may hold
+// code over a few lines. Not over more: one that is being typed would
+// swallow the code up to some later `>>`.
 function wordListEnd(input, strict) {
     let open = input.next, close = open == 171 /* Ch.GuillemetOpen */ ? 187 /* Ch.GuillemetClose */ : 62 /* Ch.Greater */;
     let count = open == 60 /* Ch.Less */ && input.peek(1) == 60 /* Ch.Less */ ? 2 : 1;
-    for (let pos = count, lines = 0, code = false;; pos++) {
+    let codeLines = open == 171 /* Ch.GuillemetOpen */ || count == 2 ? maxCodeWordListLines : 1;
+    for (let pos = count, lines = 1, code = false;; pos++) {
         let ch = input.peek(pos);
         if (ch == close && repeats(input, pos, close, count))
             return pos + count;
@@ -584,7 +1039,7 @@ function wordListEnd(input, strict) {
         else if (ch == 59 /* Ch.Semicolon */ || ch == 123 /* Ch.BraceOpen */ || ch == 125 /* Ch.BraceClose */ ||
             ch == 40 /* Ch.ParenOpen */ || ch == 41 /* Ch.ParenClose */)
             code = true;
-        if (lines && (code || strict))
+        if (lines > 1 && (code && lines > codeLines || strict))
             return -1;
         if (strict && (code || ch == 36 /* Ch.Dollar */ || ch == 64 /* Ch.At */ || ch == 37 /* Ch.Percent */ || ch == 38 /* Ch.Amp */ ||
             ch == 124 /* Ch.Pipe */ || ch == 61 /* Ch.Equals */ || ch == 44 /* Ch.Comma */ || ch == 63 /* Ch.Question */ ||
@@ -592,19 +1047,77 @@ function wordListEnd(input, strict) {
             return -1;
     }
 }
+// How many lines a <<...>> list that holds code may span.
+const maxCodeWordListLines = 10;
+// How long a <<...>> subscript can be. Whether it is closed is found
+// out from its start, and a token must not look far past its end.
+const maxDoubleSubscript = 24;
+// Whether a character can start or end the content of a <<...>>
+// subscript: part of a word, a variable or a quote. An operator
+// character cannot, which tells the hyper operators apart: @a<<+>>@b,
+// @a«R-»@b
+function isSubscriptEdge(ch) {
+    return isIdentifierStart(ch) || isDigit(ch) || ch == 39 /* Ch.Apostrophe */ || ch == 34 /* Ch.DoubleQuote */;
+}
+// The offset after the <<...>> subscript at the current position, with
+// the given opening, or -1. It is short, on one line, and holds no
+// punctuation of statements.
+function doubleSubscriptEnd(input, { start, close, count }) {
+    let first = input.peek(start);
+    if (!isSubscriptEdge(first) && first != 36 /* Ch.Dollar */ && first != 64 /* Ch.At */ && first != 37 /* Ch.Percent */ && first != 38 /* Ch.Amp */)
+        return -1;
+    for (let pos = start; pos < maxDoubleSubscript; pos++) {
+        let ch = input.peek(pos);
+        if (ch == close && repeats(input, pos, close, count))
+            return isSubscriptEdge(input.peek(pos - 1)) ? pos + count : -1;
+        if (ch < 0 || ch == 10 /* Ch.Newline */ || ch == 59 /* Ch.Semicolon */ || ch == 123 /* Ch.BraceOpen */ || ch == 125 /* Ch.BraceClose */ ||
+            ch == 40 /* Ch.ParenOpen */ || ch == 41 /* Ch.ParenClose */)
+            return -1;
+    }
+    return -1;
+}
+// Whether every `{` between two offsets has its `}` there, and the
+// other way around.
+function hasBalancedBraces(input, from, to) {
+    let depth = 0;
+    for (let pos = from; pos < to; pos++) {
+        let ch = input.peek(pos);
+        if (ch == 123 /* Ch.BraceOpen */)
+            depth++;
+        else if (ch == 125 /* Ch.BraceClose */ && --depth < 0)
+            return false;
+    }
+    return depth == 0;
+}
 // A `<` subscript right after a term: %h<key>
 function subscriptEnd(input) {
     if (input.next != 60 /* Ch.Less */ || isSpace(input.peek(-1)) || input.peek(1) == 60 /* Ch.Less */)
         return -1;
     return wordListEnd(input, true);
 }
+// The keywords that are routines or prefix operators, and can be called
+// with parentheses. `if(1)` and `my($x)` are not calls of this kind.
+const callableKeywords = /^(take|return|emit|next|last|redo|proceed|succeed|so|not)$/;
+// The words that declare what follows `multi`, `proto` or `only`.
+const declarators$1 = /^(sub|method|submethod|token|rule|regex)$/;
+// Whether a declarator starts with the given word, as `su` starts `sub`.
+function startsDeclarator(name) {
+    return ["sub", "method", "submethod", "token", "rule", "regex"].some(declarator => declarator.startsWith(name));
+}
+const operatorCategory = /^(infix|prefix|postfix|circumfix|postcircumfix|term)$/;
 function isWordOperator(name) {
     return name == "x" || name == "xx" || name == "min" || name == "max" || name == "Z" || name == "X";
 }
 // The tokens that depend on whether a term or an operator is expected.
 const termToken = new ExternalTokenizer((input, stack) => {
-    if (!stack.canShift(Regex))
+    if (!stack.canShift(regexLiteral)) {
+        // At the start of the parse of the inside of a word list that
+        // interpolates, its opening delimiter.
+        let opening = context(stack) == startContext && stack.canShift(quoteStart) ? wordListOpening(input, 0) : null;
+        if (opening)
+            input.acceptToken(quoteStart, opening.start);
         return;
+    }
     let next = input.next, { mode } = context(stack);
     if (isIdentifierStart(next)) {
         // The Z, X and R meta operators: Z+, X~, R-, Z=>
@@ -616,14 +1129,29 @@ const termToken = new ExternalTokenizer((input, stack) => {
             return input.acceptToken(wordOperator, pos);
         }
         // A word before `=>` is a key, whatever it spells.
-        let end = nameEnd(input, 0), after = end;
-        while (input.peek(after) == 32 /* Ch.Space */ || input.peek(after) == 9 /* Ch.Tab */)
-            after++;
+        let end = nameEnd(input, 0), after = gapEnd(input, end);
         if (input.peek(after) == 61 /* Ch.Equals */ && input.peek(after + 1) == 62 /* Ch.Greater */)
-            return input.acceptToken(fatArrowKey, end);
+            return input.acceptToken(plainName, end);
+        // After `multi`, `proto` or `only`, a name that is not a declarator
+        // is that of a sub: multi foo($x) { }
+        // Only with a signature or a body right after it. A name alone may
+        // be a declarator that is still being typed (`multi su`), and
+        // `only` and `proto` can be routines of one's own (`only foo, 1`).
+        // The signature may start on the next line, unless the name can
+        // still become a declarator: `multi su` above a line with a `(`.
+        if (mode == 4 /* Mode.AfterMulti */ && !(end <= 9 && declarators$1.test(word(input, 0, end)))) {
+            let nameTo = categoryEnd(input, 0, end), opens = (ch) => ch == 40 /* Ch.ParenOpen */ || ch == 123 /* Ch.BraceOpen */;
+            if (opens(input.peek(gapEnd(input, nameTo))) ||
+                opens(input.peek(gapEnd(input, nameTo, true))) && !startsDeclarator(word(input, 0, end)))
+                return input.acceptToken(multiName, nameTo);
+        }
+        // So is one of the keywords that are routines, when it is called
+        // with parentheses: take(1). They are 2 to 7 characters long.
+        if (input.peek(end) == 40 /* Ch.ParenOpen */ && end <= 7 && callableKeywords.test(word(input, 0, end)))
+            return input.acceptToken(plainName, end);
         if (mode == 1 /* Mode.AfterTerm */) {
             // x, xx, min, max, Z and X are operators where one is expected.
-            if (isWordOperator(word(input, 0, end)))
+            if (end <= 3 && isWordOperator(word(input, 0, end)))
                 input.acceptToken(wordOperator, end);
             return;
         }
@@ -632,11 +1160,20 @@ const termToken = new ExternalTokenizer((input, stack) => {
         // Squeezed between two terms, a sigil is the operator: $a%b. With a
         // space before it, it is a variable: `my Array[Int] %h`.
         if (mode == 1 /* Mode.AfterTerm */ && isIdentifierStart(input.peek(1)) && !isSpace(input.peek(-1)))
-            input.acceptToken(wordOperator, 1);
+            return input.acceptToken(wordOperator, 1);
+        // An operator as a routine: &infix:<+>
+        if (next == 38 /* Ch.Amp */) {
+            let end = nameEnd(input, 1);
+            if (end > 0 && operatorCategory.test(word(input, 1, end))) {
+                let categoryTo = categoryEnd(input, 1, end);
+                if (categoryTo > end)
+                    input.acceptToken(operatorVariable, categoryTo);
+            }
+        }
         return;
     }
     else if (next == 60 /* Ch.Less */ || next == 171 /* Ch.GuillemetOpen */) {
-        let end;
+        let end, opening = wordListOpening(input, 0);
         if (inTermPosition(input, mode, 1)) {
             // [<] and [<=] are reductions, <-> starts a pointy block.
             let after = input.peek(1);
@@ -644,19 +1181,31 @@ const termToken = new ExternalTokenizer((input, stack) => {
                 return;
             end = wordListEnd(input, false);
         }
+        else if (opening && !isSpace(input.peek(-1))) {
+            // A subscript with double angles, which touches its term:
+            // %h«$key», :a<<b $c>>
+            end = doubleSubscriptEnd(input, opening);
+        }
         else {
             end = subscriptEnd(input);
         }
-        if (end > 0)
-            input.acceptToken(rawString, end);
-        return;
+        if (end <= 0)
+            return;
+        // <<a $b>> and «a $b» interpolate. The list is one token here:
+        // that it is closed has to be known where it starts. Its inside
+        // is parsed again, piece by piece (see index.ts), by rules that
+        // count nested delimiters, escapes and the braces of blocks. A
+        // list that those rules would end elsewhere is not read inside.
+        let interpolates = opening && rawEnd(input, opening.start, opening) == end &&
+            hasBalancedBraces(input, opening.start, end);
+        return input.acceptToken(interpolates ? interpolatingWordList : rawString, end);
     }
     else if (next == 47 /* Ch.Slash */) {
         if (input.peek(1) == 47 /* Ch.Slash */ || !inTermPosition(input, mode, 1))
             return;
-        let end = regexEnd(input, 1, 47 /* Ch.Slash */, 47 /* Ch.Slash */, 1);
+        let end = regexTokenEnd(input, slashOpening);
         if (end > 0)
-            input.acceptToken(Regex, end + 1);
+            input.acceptToken(regexLiteral, end);
         return;
     }
     let opening = readOpening(input);
@@ -664,9 +1213,15 @@ const termToken = new ExternalTokenizer((input, stack) => {
         return;
     if (opening.kind == "interpolating")
         return input.acceptToken(quoteStart, opening.start);
-    let end = opening.kind == "raw" ? rawEnd(input, opening.start, opening) : regexTokenEnd(input, opening);
+    if (opening.kind != "raw") {
+        let end = regexTokenEnd(input, opening);
+        if (end > 0)
+            input.acceptToken(opening.kind == "transliteration" ? transliteration : regexLiteral, end);
+        return;
+    }
+    let end = rawEnd(input, opening.start, opening);
     if (end > 0)
-        input.acceptToken(opening.kind == "raw" ? rawString : Regex, end);
+        input.acceptToken(rawString, end);
 });
 // Whether a sigil other than `$` interpolates: only when a subscript or
 // a call follows its name. `end` is the offset after the name.
@@ -686,7 +1241,7 @@ const quoteToken = new ExternalTokenizer((input, stack) => {
     let { quote, mode } = context(stack);
     if (!quote)
         return;
-    let { open, close, count } = quote, nests = open != close;
+    let { open, close, count, interpolates } = quote, nests = open != close;
     // After a variable, a subscript or a call continues the interpolation.
     // `[` and `(` are left to the grammar's own tokens.
     if (mode == 1 /* Mode.AfterTerm */) {
@@ -697,6 +1252,9 @@ const quoteToken = new ExternalTokenizer((input, stack) => {
             return input.acceptToken(rawString, end);
     }
     let start = input.pos;
+    // The text of a heredoc ends where the input does.
+    if (input.next < 0 && quote == heredocQuote)
+        return input.acceptToken(quoteEnd);
     for (;;) {
         let next = input.next;
         if (next < 0)
@@ -708,9 +1266,24 @@ const quoteToken = new ExternalTokenizer((input, stack) => {
             input.advance(count);
             return input.acceptToken(!atClose ? quoteNestOpen : quote.depth ? quoteNestClose : quoteEnd);
         }
-        if (next == 92 /* Ch.Backslash */ || next == 36 /* Ch.Dollar */ || next == 123 /* Ch.BraceOpen */)
-            break;
-        if (next == 64 /* Ch.At */ || next == 37 /* Ch.Percent */ || next == 38 /* Ch.Amp */) {
+        if (next == 92 /* Ch.Backslash */) {
+            if (interpolates & 32 /* Interpolate.Backslash */)
+                break;
+            // Still keeps a delimiter after it from closing the quote.
+            if (quote.escapes && input.peek(1) >= 0)
+                input.advance();
+        }
+        else if (next == 36 /* Ch.Dollar */) {
+            if (interpolates & 2 /* Interpolate.Scalar */)
+                break;
+        }
+        else if (next == 123 /* Ch.BraceOpen */) {
+            if (interpolates & 1 /* Interpolate.Closure */)
+                break;
+        }
+        else if (next == 64 /* Ch.At */ && interpolates & 4 /* Interpolate.Array */ ||
+            next == 37 /* Ch.Percent */ && interpolates & 8 /* Interpolate.Hash */ ||
+            next == 38 /* Ch.Amp */ && interpolates & 16 /* Interpolate.Function */) {
             let end = nameEnd(input, 1);
             if (end > 0 && hasPostfix(input, end))
                 break;
@@ -723,37 +1296,27 @@ const quoteToken = new ExternalTokenizer((input, stack) => {
 // The text of a heredoc: the lines after the one that holds its opener,
 // up to the line that holds only its terminator. As a skipped token, it
 // leaves the rest of the opener's line to be parsed as usual. The
-// opener is looked up in the text of that line rather than kept in the
-// context, so that it is also found when the line's nodes were reused
-// from an earlier parse.
-const heredocToken = new ExternalTokenizer(input => {
+// context holds the terminators of the heredocs that the line opened.
+//
+// The text is one token, also when it interpolates: that it has a
+// terminator has to be known where it starts. A text in which
+// everything interpolates is a token of its own kind, the inside of
+// which is parsed again (see index.ts), from an empty token that puts
+// the quote in the context. When a line opens several heredocs, their
+// texts are one token, which interpolates if all of them do.
+const heredocToken = new ExternalTokenizer((input, stack) => {
+    if (context(stack) == startContext && stack.canShift(heredocStart))
+        return input.acceptToken(heredocStart);
+    let { heredocs } = context(stack);
+    if (!heredocs.length)
+        return;
     let pos = blanksEnd(input, 0);
     if (input.peek(pos) != 10 /* Ch.Newline */)
         return;
-    // Read the line that just ended, and look for heredoc openers in it.
-    let lineStart = 0;
-    while (lineStart > -500 && input.peek(lineStart - 1) >= 0 && input.peek(lineStart - 1) != 10 /* Ch.Newline */)
-        lineStart--;
-    let line = word(input, lineStart, 0);
-    if (line.indexOf(":to") < 0 && line.indexOf(":heredoc") < 0 || /^\s*#/.test(line))
-        return;
-    let opener = /(?:^|[^\w$@%&.'-])[qQ]\w*(?::\w+)*:(?:to|heredoc)(?::\w+)*\s*(\S)/g, found;
-    let terminators = [];
-    while (found = opener.exec(line)) {
-        let open = found[1], close = String.fromCharCode(brackets[open.charCodeAt(0)] || open.charCodeAt(0));
-        let end = line.indexOf(close, opener.lastIndex);
-        if (end < 0)
-            continue;
-        terminators.push(line.slice(opener.lastIndex, end).trim());
-        opener.lastIndex = end + 1;
-    }
-    if (!terminators.length)
-        return;
     input.advance(pos);
-    for (let terminator of terminators) {
+    for (let { terminator } of heredocs) {
         for (;;) {
-            // Without its terminator, this is not taken to be a heredoc. The
-            // opener is found by its text, and may be in a comment or a string.
+            // Without its terminator, this is not taken to be a heredoc.
             if (input.next < 0)
                 return;
             input.advance();
@@ -764,22 +1327,218 @@ const heredocToken = new ExternalTokenizer(input => {
             skipLine(input);
         }
     }
-    input.acceptToken(Heredoc);
+    input.acceptToken(heredocs.every(heredoc => heredoc.interpolates) ? interpolatingHeredoc : rawHeredoc);
 });
-// The body of a token, rule or regex declaration, up to its closing brace.
-const regexBodyToken = new ExternalTokenizer((input, stack) => {
-    if (!stack.canShift(regexBody))
+const regexDeclarator = /^(token|rule|regex)$/;
+const regexDeclaratorPrefix = /^(proto|multi|my|our)$/;
+// Whether the line that starts at offset `pos` starts a regex
+// declaration: a declarator, a name, and further on a brace, as in
+// `token name {`. In a regex, the words alone can be literals:
+// `token | rule`
+function startsRegexDeclaration(input, pos) {
+    let start = blanksEnd(input, pos), end = nameEnd(input, start);
+    // proto token, my regex
+    if (end > 0 && isBlank(input.peek(end)) && regexDeclaratorPrefix.test(word(input, start, end))) {
+        start = blanksEnd(input, end);
+        end = nameEnd(input, start);
+    }
+    if (end < 0 || end - start > 5 || !isBlank(input.peek(end)) || !regexDeclarator.test(word(input, start, end)))
+        return false;
+    let name = blanksEnd(input, end), after = nameEnd(input, name);
+    if (after < 0)
+        return false;
+    for (after = categoryEnd(input, name, after);; after++) {
+        let next = input.peek(after);
+        if (next == 123 /* Ch.BraceOpen */)
+            return true;
+        if (next < 0 || next == 10 /* Ch.Newline */)
+            return false;
+    }
+}
+// The characters that quantify, combine and anchor in a regex.
+function isRegexOperator(ch) {
+    return ch == 43 /* Ch.Plus */ || ch == 42 /* Ch.Star */ || ch == 63 /* Ch.Question */ || ch == 124 /* Ch.Pipe */ || ch == 38 /* Ch.Amp */ || ch == 94 /* Ch.Caret */ ||
+        ch == 126 /* Ch.Tilde */ || ch == 37 /* Ch.Percent */;
+}
+// The offset after the `<...>` at the current position in a regex.
+// When it is not closed on its line, this is the negated offset of the
+// end of the text that was gone over to find that out.
+function assertionEnd(input) {
+    for (let pos = 1, depth = 1;;) {
+        let ch = input.peek(pos);
+        if (ch < 0 || ch == 10 /* Ch.Newline */)
+            return -pos;
+        if (ch == 92 /* Ch.Backslash */) {
+            pos += input.peek(pos + 1) == 10 /* Ch.Newline */ || input.peek(pos + 1) < 0 ? 1 : 2;
+        }
+        else if (ch == 39 /* Ch.Apostrophe */ || ch == 34 /* Ch.DoubleQuote */) {
+            let end = quotedEnd(input, pos);
+            pos = end < 0 ? pos + 1 : end;
+        }
+        else if (ch == 91 /* Ch.BracketOpen */) {
+            // The brackets of a character class can hold a `>` and a `}`,
+            // and can span lines.
+            let end = pos + 1;
+            while (input.peek(end) != 93 /* Ch.BracketClose */ && input.peek(end) >= 0)
+                end += input.peek(end) == 92 /* Ch.Backslash */ ? 2 : 1;
+            pos = input.peek(end) == 93 /* Ch.BracketClose */ ? end + 1 : pos + 1;
+        }
+        else if (ch == 123 /* Ch.BraceOpen */) {
+            // So can a block of code: <?{ $x > 1 }>
+            let end = pos + 1;
+            for (let braces = 1; braces > 0; end++) {
+                let inner = input.peek(end);
+                if (inner < 0 || inner == 10 /* Ch.Newline */)
+                    return -pos;
+                if (inner == 123 /* Ch.BraceOpen */)
+                    braces++;
+                else if (inner == 125 /* Ch.BraceClose */)
+                    braces--;
+            }
+            pos = end;
+        }
+        else if (ch == 60 /* Ch.Less */) {
+            depth++;
+            pos++;
+        }
+        else if (ch == 62 /* Ch.Greater */) {
+            pos++;
+            if (--depth == 0)
+                return pos;
+        }
+        else {
+            pos++;
+        }
+    }
+}
+// The pieces of the body of a token, rule or regex declaration. The
+// context tells whether the position is in such a body, and whether it
+// is in a block of code there, which is left to the other tokenizers.
+const regexToken = new ExternalTokenizer((input, stack) => {
+    let current = context(stack), { regex } = current, next = input.next;
+    if (!regex || regex.braces > 0) {
+        // At the start of the parse of the inside of a regex literal, the
+        // opening delimiter: `/`, or a quote word with its adverbs: rx:i/
+        if (current == startContext && stack.canShift(regexLitOpen)) {
+            let opening = regexOpening(input);
+            if (opening)
+                input.acceptToken(regexLitOpen, opening.start);
+            return;
+        }
+        // Outside of a regex, or in a block of code in one, where another
+        // regex can be declared. An empty body, `{}`, has no regex.
+        if (next >= 0 && next != 125 /* Ch.BraceClose */ && stack.canShift(regexStart))
+            input.acceptToken(regexStart);
         return;
-    let end = regexEnd(input, 0, 123 /* Ch.BraceOpen */, 125 /* Ch.BraceClose */, 1);
-    if (end < 0) {
-        // Not closed: the rest of the input.
-        skipToEnd(input);
-        if (input.pos > stack.pos)
-            input.acceptToken(regexBody);
     }
-    else if (end > 0) {
-        input.acceptToken(regexBody, end);
+    let { literalEnd } = regex;
+    if (literalEnd >= 0) {
+        // A literal ends at its closing delimiter. The rest of what is
+        // parsed, which for s/a/b/ includes the replacement, is one token.
+        if (next < 0 || input.pos >= literalEnd) {
+            skipToEnd(input);
+            return input.acceptToken(regexLitClose);
+        }
+    }
+    else if (next < 0 || next == 125 /* Ch.BraceClose */ || next == 10 /* Ch.Newline */ && startsRegexDeclaration(input, 1)) {
+        // The body ends at its closing brace. One that is not closed ends
+        // before the next regex declaration, which a body does not hold, so
+        // that the declarations after it are still found.
+        return input.acceptToken(regexBodyEnd);
     }
+    // A block of code, and an escape, are tokens of the grammar. An
+    // escape does not take a line break, where the check above is made.
+    if (next == 123 /* Ch.BraceOpen */)
+        return;
+    if (next == 92 /* Ch.Backslash */ && input.peek(1) >= 0 && input.peek(1) != 10 /* Ch.Newline */)
+        return;
+    // How far a piece of a literal can go: up to its closing delimiter.
+    // The pieces are read by other rules than the ones that found that
+    // delimiter, and where the two disagree, the delimiter wins. A piece
+    // that would go over it is text.
+    let limit = literalEnd < 0 ? Infinity : literalEnd - input.pos;
+    if (next == 35 /* Ch.Hash */) {
+        // An embedded comment, #`( ... ), or one that runs to the end of the line.
+        let end = embeddedCommentEnd(input, 0);
+        if (end > 0)
+            return input.acceptToken(regexBlockComment, end);
+        skipLine(input);
+        return input.acceptToken(regexComment);
+    }
+    if (next == 39 /* Ch.Apostrophe */ || next == 34 /* Ch.DoubleQuote */) {
+        let end = quotedEnd(input, 0);
+        if (end > 0 && end <= limit)
+            return input.acceptToken(regexQuote, end);
+    }
+    else if (next == 60 /* Ch.Less */ || next == 62 /* Ch.Greater */ || next == 171 /* Ch.GuillemetOpen */ || next == 187 /* Ch.GuillemetClose */ ||
+        next == 41 /* Ch.ParenClose */ && input.peek(1) == 62 /* Ch.Greater */) {
+        // Word boundaries and capture markers stand alone: << >> « » <( )>
+        let after = input.peek(1);
+        if (next != 60 /* Ch.Less */ || after == 60 /* Ch.Less */ || after == 40 /* Ch.ParenOpen */) {
+            let size = next == 171 /* Ch.GuillemetOpen */ || next == 187 /* Ch.GuillemetClose */ ? 1 : 2;
+            if (next != 62 /* Ch.Greater */ || after == 62 /* Ch.Greater */)
+                return input.acceptToken(regexOperator, size);
+        }
+        else {
+            let end = assertionEnd(input);
+            if (end > limit)
+                return input.acceptToken(regexText, 1);
+            if (end > 0) {
+                // <[a..z]>, <-[a]>, <+alpha-[b]>, <?[c]>
+                let kind = after == 63 /* Ch.Question */ || after == 33 /* Ch.Bang */ ? input.peek(2) : after;
+                let isClass = kind == 91 /* Ch.BracketOpen */ || kind == 45 /* Ch.Hyphen */ || kind == 43 /* Ch.Plus */;
+                return input.acceptToken(isClass ? CharacterClass : Assertion, end);
+            }
+            // What is not closed is text, up to the brace that closes the
+            // body if there is one on the line.
+            let stop = 1;
+            while (stop < -end && input.peek(stop) != 125 /* Ch.BraceClose */)
+                stop++;
+            return input.acceptToken(regexText, stop);
+        }
+    }
+    else if (next == 36 /* Ch.Dollar */ || next == 64 /* Ch.At */) {
+        let after = input.peek(1);
+        // A named capture: $<name>
+        if (next == 36 /* Ch.Dollar */ && after == 60 /* Ch.Less */) {
+            let end = nameEnd(input, 2);
+            if (end > 0 && input.peek(end) == 62 /* Ch.Greater */)
+                return input.acceptToken(regexCapture, end + 1);
+        }
+        // A variable is a token of the grammar: $x, $0, $/, @list, $!attr, $*dynamic
+        // Not the `$` before the delimiter that closes a literal: /a$/
+        if (limit != 1) {
+            if (isIdentifierStart(after) || next == 36 /* Ch.Dollar */ && (isDigit(after) || after == 47 /* Ch.Slash */))
+                return;
+            if ((after == 33 /* Ch.Bang */ || after == 46 /* Ch.Dot */ || after == 42 /* Ch.Star */ || after == 63 /* Ch.Question */) &&
+                isIdentifierStart(input.peek(2)))
+                return;
+        }
+        // Otherwise `$` and `$$` anchor.
+        if (next == 36 /* Ch.Dollar */) {
+            while (input.next == 36 /* Ch.Dollar */ && input.pos != literalEnd)
+                input.advance();
+            return input.acceptToken(regexOperator);
+        }
+    }
+    else if (isRegexOperator(next)) {
+        while (isRegexOperator(input.next) && input.pos != literalEnd)
+            input.advance();
+        return input.acceptToken(regexOperator);
+    }
+    // Text, up to where one of the above may apply.
+    for (;;) {
+        input.advance();
+        let ch = input.next;
+        if (ch < 0 || input.pos == literalEnd ||
+            ch == 10 /* Ch.Newline */ || ch == 92 /* Ch.Backslash */ || ch == 39 /* Ch.Apostrophe */ || ch == 34 /* Ch.DoubleQuote */ ||
+            ch == 60 /* Ch.Less */ || ch == 62 /* Ch.Greater */ || ch == 171 /* Ch.GuillemetOpen */ || ch == 187 /* Ch.GuillemetClose */ ||
+            ch == 41 /* Ch.ParenClose */ && input.peek(1) == 62 /* Ch.Greater */ ||
+            ch == 123 /* Ch.BraceOpen */ || ch == 125 /* Ch.BraceClose */ || ch == 35 /* Ch.Hash */ || ch == 36 /* Ch.Dollar */ ||
+            ch == 64 /* Ch.At */ || isRegexOperator(ch))
+            break;
+    }
+    input.acceptToken(regexText);
 });
 // ---- Names ----
 // The dot of a method call, with its optional `?`, `+`, `*`, `^` or `&`
@@ -800,20 +1559,32 @@ const methodDotToken = new ExternalTokenizer((input, stack) => {
         return;
     input.acceptToken(methodDot, size);
 });
-// The offset after an operator name's `:<...>` part, as in infix:<+>
-// and term:sym<x>, or `pos` when there is none there.
-function categoryEnd(input, pos) {
+// The offset after an operator name's `:<...>` part, as in infix:<+>,
+// circumfix:<[ ]>, infix:['+'] and term:sym<x>, or `pos` when there is
+// none there. The name before it runs from `nameStart` to `pos`.
+function categoryEnd(input, nameStart, pos) {
     if (input.peek(pos) != 58 /* Ch.Colon */)
         return pos;
     let open = pos + 1;
     if (word(input, open, open + 3) == "sym")
         open += 3;
-    let close = input.peek(open) == 60 /* Ch.Less */ ? 62 /* Ch.Greater */ : input.peek(open) == 171 /* Ch.GuillemetOpen */ ? 187 /* Ch.GuillemetClose */ : -1;
+    let first = input.peek(open);
+    if (first == 91 /* Ch.BracketOpen */) {
+        // Only a quoted operator: ['+']
+        let quote = input.peek(open + 1);
+        if (quote != 39 /* Ch.Apostrophe */ && quote != 34 /* Ch.DoubleQuote */)
+            return pos;
+        let end = quotedEnd(input, open + 1);
+        return end > 0 && input.peek(end) == 93 /* Ch.BracketClose */ ? end + 1 : pos;
+    }
+    let close = first == 60 /* Ch.Less */ ? 62 /* Ch.Greater */ : first == 171 /* Ch.GuillemetOpen */ ? 187 /* Ch.GuillemetClose */ : -1;
     if (close < 0)
         return pos;
+    // The two halves of a circumfix are separated by one space.
+    let spaces = /circumfix$/.test(word(input, nameStart, pos)) ? 1 : 0;
     for (let i = open + 1;; i++) {
         let ch = input.peek(i);
-        if (ch < 0 || isSpace(ch))
+        if (ch < 0 || isSpace(ch) && (ch != 32 /* Ch.Space */ || i == open + 1 || --spaces < 0))
             return pos;
         // The operator itself can be `>`, so the last closer before a break counts.
         if (ch == close && !(input.peek(i + 1) == close))
@@ -834,7 +1605,7 @@ const nameToken = new ExternalTokenizer((input, stack) => {
             input.acceptToken(MethodName, end);
         return;
     }
-    end = categoryEnd(input, end);
+    end = categoryEnd(input, mark, end);
     if (!mark && stack.canShift(declaredName))
         input.acceptToken(declaredName, end);
     else if (stack.canShift(declaredMethodName))
@@ -842,12 +1613,20 @@ const nameToken = new ExternalTokenizer((input, stack) => {
 });
 // The type smiley in Int:D, Str:U and Any:_. It has to touch the type
 // name, and must not be the start of a longer pair such as :Default.
+//
+// A type name without a smiley ends in an empty token. Without it, the
+// parser has to read the token after the name to know that the name is
+// complete, and when a long comment is in between, it records that as
+// a lookahead, which keeps the tokens before it from being reused.
 const smileyToken = new ExternalTokenizer((input, stack) => {
-    if (input.next != 58 /* Ch.Colon */ || !stack.canShift(smiley) || !continuesName(input, -1))
+    if (!stack.canShift(noSmiley))
         return;
-    let kind = input.peek(1);
-    if ((kind == 68 /* Ch.D */ || kind == 85 /* Ch.U */ || kind == 95 /* Ch.Underscore */) && !continuesName(input, 2))
-        input.acceptToken(smiley, 2);
+    if (input.next == 58 /* Ch.Colon */) {
+        let kind = input.peek(1);
+        if ((kind == 68 /* Ch.D */ || kind == 85 /* Ch.U */ || kind == 95 /* Ch.Underscore */) && !continuesName(input, 2))
+            return input.acceptToken(smiley, 2);
+    }
+    input.acceptToken(noSmiley, 0);
 });
 // v6, v6.d, v1.2.3, v1.2+, v1.*. A name such as v8-engine is not a version.
 const versionToken = new ExternalTokenizer((input, stack) => {
@@ -882,27 +1661,27 @@ const versionToken = new ExternalTokenizer((input, stack) => {
 });
 
 // This file was generated by lezer-generator. You probably shouldn't edit it.
-const spec_identifier = {__proto__:null,class:42, role:44, grammar:46, module:48, package:50, sub:64, method:68, submethod:70, token:76, rule:78, regex:80, enum:88, subset:94, constant:100, my:126, our:128, has:130, state:132, temp:134, let:136, anon:138, augment:140, supersede:142, unit:144, multi:146, proto:148, only:150, if:152, elsif:154, else:156, unless:158, with:160, orwith:162, without:164, for:166, while:168, until:170, loop:172, repeat:174, given:176, when:178, default:180, do:182, gather:184, take:186, try:188, return:190, next:192, last:194, redo:196, proceed:198, succeed:200, react:202, whenever:204, supply:206, emit:208, start:210, use:212, need:214, import:216, require:218, no:220, is:222, does:224, of:226, returns:228, handles:230, where:232, will:234, trusts:236, hides:238, and:240, or:242, not:244, xor:246, so:248, andthen:250, orelse:252, notandthen:254, div:256, mod:258, gcd:260, lcm:262, eq:264, ne:266, lt:268, gt:270, le:272, ge:274, cmp:276, leg:278, eqv:280, but:282, self:284};
-const spec_capIdentifier = {__proto__:null,True:286, False:288, Nil:290, BEGIN:292, CHECK:294, INIT:296, END:298, ENTER:300, LEAVE:302, KEEP:304, UNDO:306, FIRST:308, NEXT:310, LAST:312, PRE:314, POST:316, CATCH:318, CONTROL:320, QUIT:322, CLOSE:324, DOC:326};
+const spec_identifier = {__proto__:null,class:80, role:82, grammar:84, module:86, package:88, sub:102, method:106, submethod:108, token:116, rule:118, regex:120, enum:140, subset:146, constant:152, my:170, our:172, has:174, state:176, temp:178, let:180, anon:182, augment:184, supersede:186, unit:188, multi:190, proto:192, only:194, if:196, elsif:198, else:200, unless:202, with:204, orwith:206, without:208, for:210, while:212, until:214, loop:216, repeat:218, given:220, when:222, default:224, do:226, gather:228, take:230, try:232, return:234, next:236, last:238, redo:240, proceed:242, succeed:244, react:246, whenever:248, supply:250, emit:252, start:254, use:256, need:258, import:260, require:262, no:264, is:266, does:268, of:270, returns:272, handles:274, where:276, will:278, trusts:280, hides:282, and:284, or:286, not:288, xor:290, so:292, andthen:294, orelse:296, notandthen:298, div:300, mod:302, gcd:304, lcm:306, eq:308, ne:310, lt:312, gt:314, le:316, ge:318, cmp:320, leg:322, eqv:324, but:326, self:328};
+const spec_capIdentifier = {__proto__:null,True:330, False:332, Nil:334, BEGIN:336, CHECK:338, INIT:340, END:342, ENTER:344, LEAVE:346, KEEP:348, UNDO:350, FIRST:352, NEXT:354, LAST:356, PRE:358, POST:360, CATCH:362, CONTROL:364, QUIT:366, CLOSE:368, DOC:370};
 const parser$1 = LRParser.deserialize({
   version: 14,
-  states: "*hQfQDTOOO*kQDTO'#ClO*rQDTO'#CoO*yQDTO'#CyO+QQ7sO'#DbOOQ-w'#Df'#DfO+VQDuO'#DgOOQ-w'#Di'#DiO5fO!0bO'#DiOOQ-w'#G]'#G]OOQ-w'#G['#G[OOQ-w'#Fz'#FzQfQDTOOO>rQDeO'#CpO>yQDeO'#C{O?QQDeO'#C{OHZQDeO'#DROHeQDeO'#DXO!#yQDeO'#D[O!-_QDeO'#D_OOQ-w'#Gb'#GbOOQ-w,59W,59WO!6sQDTO,59WOOQ-w,59Z,59ZO!6zQDTO,59ZOOQ-w,59e,59eO!7RQDTO,59eOOQ-w,59|,59|OOQ-w,5:R,5:RO!7YQDTO'#DkOOO1x'#F|'#F|O!7aO!0bO,5:TOOQ-w,5:T,5:TOOQ-w-E9x-E9xOOQ-w'#Cv'#CvOOQ-w'#F{'#F{O!@jQDTO'#G_OOQ-w'#G_'#G_OOQ-w,59[,59[O5mQDTO,59[OOQ-w'#C}'#C}OOQ-w,59g,59gO5mQDTO,59gOOQ-w'#DQ'#DQO!@qQDTO,59mOOQ-w'#DV'#DVO!@xQ:XO'#DWOOQ-w,59m,59mO!@qQDTO,59mOOQ-w'#DZ'#DZOOQ-w,59s,59sOOQ-w'#D^'#D^OOQ-w,59v,59vOOQ-w'#Da'#DaOOQ-w,59y,59yOOQ-w1G.r1G.rOOQ-w1G.u1G.uOOQ-w1G/P1G/POOO1x,5:V,5:VO!AQQDTO,5:VOOO1x-E9z-E9zOOQ-w1G/o1G/oOOQ-w-E9y-E9yOOQ-w,5<y,5<yOOQ-w1G.v1G.vOOQ-w1G/R1G/ROOQ-w1G/X1G/XOOQ-w,59r,59rO!AXQ7cO,59rO!A^QDTO1G/XOOO1x1G/q1G/qOOQ-w1G/^1G/^OOQ-w7+$s7+$s",
-  stateData: "!Aq~O$}OSYOSZOSPOSQOSROS~OSSOUXOWXOXXO]XO_PObQOe]Of]Og]Oh]Oi]OlROnYOp^Or_Os_Ov`Ow`Ox`O|aO!PbO!ScO!VXO!WXO!XXO![XO!`XO!adO!bdO!cdO!ddO!edO!fdO!gdO!hdO!idO!jdO!kdO!ldO!mdO!ndO!odO!pdO!qdO!rdO!sdO!tdO!udO!vdO!wdO!xdO!ydO!zdO!{dO!|dO!}dO#OdO#PdO#QdO#RdO#SdO#TdO#UdO#VdO#WdO#XdO#YdO#ZdO#[dO#]dO#^dO#_dO#`dO#adO#bdO#cdO#ddO#edO#fdO#gdO#hdO#idO#jdO#kdO#ldO#mdO#ndO#odO#pdO#qdO#rdO#sdO#tdO#udO#vdO#wdO#xdO#ydO#zdO#{dO#|dO#}dO$OdO$PdO$QdO$RdO$SdO$TdO$UdO$VdO$WdO$XdO$YdO$ZdO$[dO$]dO$^dO$_dO$`dO$adO$bdO$cdO$ddO$edO$fdO$gdO$hdO$idO$jXO$kXO$lXO$mXO$yVO$zWO${TO%QTO%SUO%TXO~O^eO~PfOagO~PfOkiO~PfOTkO~O$tlOS!ZXU!ZXW!ZXX!ZX]!ZX_!ZXb!ZXe!ZXf!ZXg!ZXh!ZXi!ZXl!ZXn!ZXp!ZXr!ZXs!ZXv!ZXw!ZXx!ZX|!ZX!P!ZX!S!ZX!V!ZX!W!ZX!X!ZX![!ZX!`!ZX!a!ZX!b!ZX!c!ZX!d!ZX!e!ZX!f!ZX!g!ZX!h!ZX!i!ZX!j!ZX!k!ZX!l!ZX!m!ZX!n!ZX!o!ZX!p!ZX!q!ZX!r!ZX!s!ZX!t!ZX!u!ZX!v!ZX!w!ZX!x!ZX!y!ZX!z!ZX!{!ZX!|!ZX!}!ZX#O!ZX#P!ZX#Q!ZX#R!ZX#S!ZX#T!ZX#U!ZX#V!ZX#W!ZX#X!ZX#Y!ZX#Z!ZX#[!ZX#]!ZX#^!ZX#_!ZX#`!ZX#a!ZX#b!ZX#c!ZX#d!ZX#e!ZX#f!ZX#g!ZX#h!ZX#i!ZX#j!ZX#k!ZX#l!ZX#m!ZX#n!ZX#o!ZX#p!ZX#q!ZX#r!ZX#s!ZX#t!ZX#u!ZX#v!ZX#w!ZX#x!ZX#y!ZX#z!ZX#{!ZX#|!ZX#}!ZX$O!ZX$P!ZX$Q!ZX$R!ZX$S!ZX$T!ZX$U!ZX$V!ZX$W!ZX$X!ZX$Y!ZX$Z!ZX$[!ZX$]!ZX$^!ZX$_!ZX$`!ZX$a!ZX$b!ZX$c!ZX$d!ZX$e!ZX$f!ZX$g!ZX$h!ZX$i!ZX$j!ZX$k!ZX$l!ZX$m!ZX$q!ZX$y!ZX$z!ZX${!ZX%Q!ZX%S!ZX%T!ZX^!ZXa!ZXk!ZX~OSSO_PObQOlmO!VnO!WnO!XnO!^nO$unO$vnO$wnO$ynO%TnO~O$xpO~P4kOSSOUXOWXOXXO]XO_PObQOe]Of]Og]Oh]Oi]OlROnuOp^Or_Os_Ov`Ow`Ox`O|aO!PbO!ScO!VXO!WXO!XXO![XO!`XO!adO!bdO!cdO!ddO!edO!fdO!gdO!hdO!idO!jdO!kdO!ldO!mdO!ndO!odO!pdO!qdO!rdO!sdO!tdO!udO!vdO!wdO!xdO!ydO!zdO!{dO!|dO!}dO#OdO#PdO#QdO#RdO#SdO#TdO#UdO#VdO#WdO#XdO#YdO#ZdO#[dO#]dO#^dO#_dO#`dO#adO#bdO#cdO#ddO#edO#fdO#gdO#hdO#idO#jdO#kdO#ldO#mdO#ndO#odO#pdO#qdO#rdO#sdO#tdO#udO#vdO#wdO#xdO#ydO#zdO#{dO#|dO#}dO$OdO$PdO$QdO$RdO$SdO$TdO$UdO$VdO$WdO$XdO$YdO$ZdO$[dO$]dO$^dO$_dO$`dO$adO$bdO$cdO$ddO$edO$fdO$gdO$hdO$idO$jXO$kXO$lXO$mXO$yVO$zWO${TO%QTO%SUO%TXO~O$rrO~P5mO$rxO~P5mO$s{O~P5mOSSOUXOWXOXXO]XO_PObQOe]Of]Og]Oh]Oi]Ol!OOp^Or_Os_Ov`Ow`Ox`O|aO!PbO!ScO!VXO!WXO!XXO![XO!`XO!adO!bdO!cdO!ddO!edO!fdO!gdO!hdO!idO!jdO!kdO!ldO!mdO!ndO!odO!pdO!qdO!rdO!sdO!tdO!udO!vdO!wdO!xdO!ydO!zdO!{dO!|dO!}dO#OdO#PdO#QdO#RdO#SdO#TdO#UdO#VdO#WdO#XdO#YdO#ZdO#[dO#]dO#^dO#_dO#`dO#adO#bdO#cdO#ddO#edO#fdO#gdO#hdO#idO#jdO#kdO#ldO#mdO#ndO#odO#pdO#qdO#rdO#sdO#tdO#udO#vdO#wdO#xdO#ydO#zdO#{dO#|dO#}dO$OdO$PdO$QdO$RdO$SdO$TdO$UdO$VdO$WdO$XdO$YdO$ZdO$[dO$]dO$^dO$_dO$`dO$adO$bdO$cdO$ddO$edO$fdO$gdO$hdO$idO$jXO$kXO$lXO$mXO$yVO$zWO${TO%QTO%SUO%TXO~On!PO$r}O~P?XO$r!ROS{XU{XW{XX{X]{X_{Xb{Xe{Xf{Xg{Xh{Xi{Xl{Xn{Xp{Xr{Xs{Xv{Xw{Xx{X|{X!P{X!S{X!V{X!W{X!X{X![{X!`{X!a{X!b{X!c{X!d{X!e{X!f{X!g{X!h{X!i{X!j{X!k{X!l{X!m{X!n{X!o{X!p{X!q{X!r{X!s{X!t{X!u{X!v{X!w{X!x{X!y{X!z{X!{{X!|{X!}{X#O{X#P{X#Q{X#R{X#S{X#T{X#U{X#V{X#W{X#X{X#Y{X#Z{X#[{X#]{X#^{X#_{X#`{X#a{X#b{X#c{X#d{X#e{X#f{X#g{X#h{X#i{X#j{X#k{X#l{X#m{X#n{X#o{X#p{X#q{X#r{X#s{X#t{X#u{X#v{X#w{X#x{X#y{X#z{X#{{X#|{X#}{X$O{X$P{X$Q{X$R{X$S{X$T{X$U{X$V{X$W{X$X{X$Y{X$Z{X$[{X$]{X$^{X$_{X$`{X$a{X$b{X$c{X$d{X$e{X$f{X$g{X$h{X$i{X$j{X$k{X$l{X$m{X$q{X$y{X$z{X${{X%Q{X%S{X%T{X^{Xa{Xk{X~O$r!TOS!OXU!OXW!OXX!OX]!OX_!OXb!OXe!OXf!OXg!OXh!OXi!OXl!OXn!OXp!OXr!OXs!OXv!OXw!OXx!OX|!OX!P!OX!S!OX!V!OX!W!OX!X!OX![!OX!`!OX!a!OX!b!OX!c!OX!d!OX!e!OX!f!OX!g!OX!h!OX!i!OX!j!OX!k!OX!l!OX!m!OX!n!OX!o!OX!p!OX!q!OX!r!OX!s!OX!t!OX!u!OX!v!OX!w!OX!x!OX!y!OX!z!OX!{!OX!|!OX!}!OX#O!OX#P!OX#Q!OX#R!OX#S!OX#T!OX#U!OX#V!OX#W!OX#X!OX#Y!OX#Z!OX#[!OX#]!OX#^!OX#_!OX#`!OX#a!OX#b!OX#c!OX#d!OX#e!OX#f!OX#g!OX#h!OX#i!OX#j!OX#k!OX#l!OX#m!OX#n!OX#o!OX#p!OX#q!OX#r!OX#s!OX#t!OX#u!OX#v!OX#w!OX#x!OX#y!OX#z!OX#{!OX#|!OX#}!OX$O!OX$P!OX$Q!OX$R!OX$S!OX$T!OX$U!OX$V!OX$W!OX$X!OX$Y!OX$Z!OX$[!OX$]!OX$^!OX$_!OX$`!OX$a!OX$b!OX$c!OX$d!OX$e!OX$f!OX$g!OX$h!OX$i!OX$j!OX$k!OX$l!OX$m!OX$q!OX$y!OX$z!OX${!OX%Q!OX%S!OX%T!OX^!OXa!OXk!OX~O$r!VOS!RXU!RXW!RXX!RX]!RX_!RXb!RXe!RXf!RXg!RXh!RXi!RXl!RXn!RXp!RXr!RXs!RXv!RXw!RXx!RX|!RX!P!RX!S!RX!V!RX!W!RX!X!RX![!RX!`!RX!a!RX!b!RX!c!RX!d!RX!e!RX!f!RX!g!RX!h!RX!i!RX!j!RX!k!RX!l!RX!m!RX!n!RX!o!RX!p!RX!q!RX!r!RX!s!RX!t!RX!u!RX!v!RX!w!RX!x!RX!y!RX!z!RX!{!RX!|!RX!}!RX#O!RX#P!RX#Q!RX#R!RX#S!RX#T!RX#U!RX#V!RX#W!RX#X!RX#Y!RX#Z!RX#[!RX#]!RX#^!RX#_!RX#`!RX#a!RX#b!RX#c!RX#d!RX#e!RX#f!RX#g!RX#h!RX#i!RX#j!RX#k!RX#l!RX#m!RX#n!RX#o!RX#p!RX#q!RX#r!RX#s!RX#t!RX#u!RX#v!RX#w!RX#x!RX#y!RX#z!RX#{!RX#|!RX#}!RX$O!RX$P!RX$Q!RX$R!RX$S!RX$T!RX$U!RX$V!RX$W!RX$X!RX$Y!RX$Z!RX$[!RX$]!RX$^!RX$_!RX$`!RX$a!RX$b!RX$c!RX$d!RX$e!RX$f!RX$g!RX$h!RX$i!RX$j!RX$k!RX$l!RX$m!RX$q!RX$y!RX$z!RX${!RX%Q!RX%S!RX%T!RX^!RXa!RXk!RX~O^!XO~PfOa!YO~PfOk!ZO~PfOk![O~PfO$x!_O~P4kOSSOUXOWXOXXO]XO_PObQOe]Of]Og]Oh]Oi]OlROp^Or_Os_Ov`Ow`Ox`O|aO!PbO!ScO!VXO!WXO!XXO![XO!`XO!adO!bdO!cdO!ddO!edO!fdO!gdO!hdO!idO!jdO!kdO!ldO!mdO!ndO!odO!pdO!qdO!rdO!sdO!tdO!udO!vdO!wdO!xdO!ydO!zdO!{dO!|dO!}dO#OdO#PdO#QdO#RdO#SdO#TdO#UdO#VdO#WdO#XdO#YdO#ZdO#[dO#]dO#^dO#_dO#`dO#adO#bdO#cdO#ddO#edO#fdO#gdO#hdO#idO#jdO#kdO#ldO#mdO#ndO#odO#pdO#qdO#rdO#sdO#tdO#udO#vdO#wdO#xdO#ydO#zdO#{dO#|dO#}dO$OdO$PdO$QdO$RdO$SdO$TdO$UdO$VdO$WdO$XdO$YdO$ZdO$[dO$]dO$^dO$_dO$`dO$adO$bdO$cdO$ddO$edO$fdO$gdO$hdO$idO$jXO$kXO$lXO$mXO$yVO$zWO${TO%QTO%SUO%TXO~On!aO~P!7hOn!dO~P?XOV!fOk!eO~Ok!hO~PfOk!iO~On!jO~P?XOZY!W!X!V]!`$j%T$l$m~",
-  goto: ")d%VPPPPPPPPPPPPPPPP%WPP%W%rPPPPP&YPP&]P%rP&sPP&v%rPPP&y&|%rP'W%rP'Z%rP'^%WPPP%r%rP%rP%nPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP'a'w(ZPPPPPPPPPPPPP(a(mP)VPP%rxXOPQR[]^_`fhjmtwz|!Q!]!gTnWoyXOPQR[]^_`fhjmtwz|!Q!]!gRw]dYOPQR[fhjm!]Yu]^_wzR!atRz^Rz_R!Q`Q!P`S!d|!QR!j!gR!SaR!UbR!WcQ[OQfPQhQQjRYq[fhj!]R!]mYt]^_wzQ|`U!`t|!gR!g!QQoWR!^oeZOPQR[fhjm!]dYOPQR[fhjm!]es]^_`twz|!Q!gQv]Sy^_Q!bwR!cz",
-  nodeNames: "⚠ BlockComment Pod Heredoc . MethodName Version Regex Regex Operator LineComment DocComment Program Number ) ( Parens ] [ Brackets PackageDeclaration class role grammar module package PackageName } { Block ; RoutineDeclaration sub RoutineName method submethod RoutineName RegexDeclaration token rule regex RegexName Block EnumDeclaration enum EnumName SubsetDeclaration subset SubsetName ConstantDeclaration constant ConstantName MethodCall VariableName AttributeName SpecialVariable Identifier TypeName Number StringLiteral Escape Interpolation PairKey my our has state temp let anon augment supersede unit multi proto only if elsif else unless with orwith without for while until loop repeat given when default do gather take try return next last redo proceed succeed react whenever supply emit start use need import require no is does of returns handles where will trusts hides and or not xor so andthen orelse notandthen div mod gcd lcm eq ne lt gt le ge cmp leg eqv but self True False Nil BEGIN CHECK INIT END ENTER LEAVE KEEP UNDO FIRST NEXT LAST PRE POST CATCH CONTROL QUIT CLOSE DOC Operator , : .",
-  maxTerm: 190,
+  states: ".WQfQDdOOO*zO#tOOO+POWOOO+UO,UOOO+uOSO'#C{O,PQDdO'#DPO,WQDdO'#DSO,_QDdO'#D^OOQ.W'#Df'#DfO,fQDdO'#D`O5zQ8WO'#D|OOQ.W'#D}'#D}O6PQ7gO'#EOOOQ.W'#EQ'#EQO7SO!0jO'#EQOOQ.W'#HS'#HSOOQ.W'#HR'#HROOQ.W'#Ge'#GeQfQDdOOO7ZQEUO'#DTO7bQEUO'#D`O7iQEUO'#D`OARQEUO'#DgOA]QEUO'#DsOKQQEUO'#DvO!&uQEUO'#DyOOQ.W'#HZ'#HZO!0jO!!^OOO!1hO!0jOOOOOS'#Gf'#GfO!1oOSO,59gOOQ.W,59g,59gOOQ.W,59k,59kO!1yQDdO,59kOOQ.W,59n,59nO!2QQDdO,59nOOQ.W,59x,59xO!2XQDdO,59xOOQ.W'#Gg'#GgO!;qQDdO'#HUOOQ.W'#HU'#HUOOQ.W,59z,59zOOQ.W,5:h,5:hOOQ.W,5:j,5:jO!;xQDdO'#EROOO2Q'#HX'#HXOOO2Q'#Gi'#GiO!<PO!0jO,5:lOOQ.W,5:l,5:lOOQ.W-E:c-E:cOOQ.W'#DZ'#DZOOQ.W,59o,59oO,fQDdO,59oOOQ.W'#Db'#DbO,fQDdO,59zOOQ.W'#De'#DeO!<WQDdO,5:ROOQ.W'#Dk'#DkO!<_Q:[O'#DlOOQ.W,5:R,5:RO!<WQDdO,5:ROOQ.W'#Du'#DuOOQ.W,5:_,5:_OOQ.W'#Dx'#DxOOQ.W,5:b,5:bOOQ.W'#D{'#D{OOQ.W,5:e,5:eO!<gQDdO'#DrOOO#t'#HV'#HVOOO#t'#Gh'#GhO!0jO!!^OOQOOOOOO!1hO!0jOOOOOS-E:d-E:dOOQ.W1G/R1G/ROOQ.W1G/V1G/VOOQ.W1G/Y1G/YOOQ.W1G/d1G/dOOQ.W-E:e-E:eOOQ.W,5=p,5=pOOO2Q,5:m,5:mO!<nQDdO,5:mOOO2Q-E:g-E:gOOQ.W1G0W1G0WOOQ.W1G/Z1G/ZOOQ.W1G/f1G/fOOQ.W1G/m1G/mO!=pO!!^O'#DmOOQ.W,5:W,5:WO!=wQ7fO,5:WO!=|QDdO1G/mOOO#t,5:^,5:^O!>TQDdO,5:^OOO#t-E:f-E:fOOO2Q1G0X1G0XO!>[O!!^O,5:XOOQY,5:X,5:XOOQ.W1G/r1G/rOOQ.W7+%X7+%XOOO#t1G/x1G/xOOQY1G/s1G/s",
+  stateData: "!>o~O%tOSlOSmOSPOSZOS[OS~OQSO]YO__Og_Oh_Oi_Oj_Ok_Op_OrTOuUOxcOycOzcO{cO|cO!PVO!R`O!TdO!VeO!WeO![fO!]fO!^fO!c_O!d_O!e_O!hgO!khO!niO!s_O!v_O!wjO!xjO!yjO!zjO!{jO!|jO!}jO#OjO#PjO#QjO#RjO#SjO#TjO#UjO#VjO#WjO#XjO#YjO#ZjO#[jO#]jO#^jO#_jO#`jO#ajO#bjO#cjO#djO#ejO#fjO#gjO#hjO#ijO#jjO#kjO#ljO#mjO#njO#ojO#pjO#qjO#rjO#sjO#tjO#ujO#vjO#wjO#xjO#yjO#zjO#{jO#|jO#}jO$OjO$PjO$QjO$RjO$SjO$TjO$UjO$VjO$WjO$XjO$YjO$ZjO$[jO$]jO$^jO$_jO$`jO$ajO$bjO$cjO$djO$ejO$fjO$gjO$hjO$ijO$jjO$kjO$ljO$mjO$njO$ojO$pjO$qjO$rjO$sjO$tjO$ujO$vjO$wjO$xjO$yjO$zjO${jO$|jO$}jO%OjO%PjO%Q_O%R_O%S_O%T_O%o]O%p^O%qZO%rWO%wZO%z[O%|_O~O%hkO~O%clO~O%plO~OSmOTmOUmOVmOWmOXmOYmO%bmO~ORoO%aoO~P+ZOqpO~PfOtrO~PfO!OtO~PfOQSO]YO__Og_Oh_Oi_Oj_Ok_Op_OrTOuUOxcOycOzcO{cO|cO!PVO!RxO!TdO!VeO!WeO![fO!]fO!^fO!c_O!d_O!e_O!hgO!khO!niO!s_O!v_O!wjO!xjO!yjO!zjO!{jO!|jO!}jO#OjO#PjO#QjO#RjO#SjO#TjO#UjO#VjO#WjO#XjO#YjO#ZjO#[jO#]jO#^jO#_jO#`jO#ajO#bjO#cjO#djO#ejO#fjO#gjO#hjO#ijO#jjO#kjO#ljO#mjO#njO#ojO#pjO#qjO#rjO#sjO#tjO#ujO#vjO#wjO#xjO#yjO#zjO#{jO#|jO#}jO$OjO$PjO$QjO$RjO$SjO$TjO$UjO$VjO$WjO$XjO$YjO$ZjO$[jO$]jO$^jO$_jO$`jO$ajO$bjO$cjO$djO$ejO$fjO$gjO$hjO$ijO$jjO$kjO$ljO$mjO$njO$ojO$pjO$qjO$rjO$sjO$tjO$ujO$vjO$wjO$xjO$yjO$zjO${jO$|jO$}jO%OjO%PjO%Q_O%R_O%S_O%T_O%o]O%p^O%qZO%rWO%wZO%z[O%|_O~O^zO~O%_{O%`{O~O]YOrTOuUO!P|O!b}O!c}O!d}O!e}O%k}O%l}O%m}O%o}O%|}O~O%n!QO~P6XO%d!SO~P,fO%d!VO~P,fO%e!XO~P,fOQSO]YO__Og_Oh_Oi_Oj_Ok_Op_OrTOuUOxcOycOzcO{cO|cO!P![O!TdO!VeO!WeO![fO!]fO!^fO!c_O!d_O!e_O!hgO!khO!niO!s_O!v_O!wjO!xjO!yjO!zjO!{jO!|jO!}jO#OjO#PjO#QjO#RjO#SjO#TjO#UjO#VjO#WjO#XjO#YjO#ZjO#[jO#]jO#^jO#_jO#`jO#ajO#bjO#cjO#djO#ejO#fjO#gjO#hjO#ijO#jjO#kjO#ljO#mjO#njO#ojO#pjO#qjO#rjO#sjO#tjO#ujO#vjO#wjO#xjO#yjO#zjO#{jO#|jO#}jO$OjO$PjO$QjO$RjO$SjO$TjO$UjO$VjO$WjO$XjO$YjO$ZjO$[jO$]jO$^jO$_jO$`jO$ajO$bjO$cjO$djO$ejO$fjO$gjO$hjO$ijO$jjO$kjO$ljO$mjO$njO$ojO$pjO$qjO$rjO$sjO$tjO$ujO$vjO$wjO$xjO$yjO$zjO${jO$|jO$}jO%OjO%PjO%Q_O%R_O%S_O%T_O%o]O%p^O%qZO%rWO%wZO%z[O%|_O~O!R!]O%d!ZO~P7pO%d!_OQ!gX]!gX_!gXg!gXh!gXi!gXj!gXk!gXp!gXr!gXu!gXx!gXy!gXz!gX{!gX|!gX!P!gX!R!gX!T!gX!V!gX!W!gX![!gX!]!gX!^!gX!c!gX!d!gX!e!gX!h!gX!k!gX!n!gX!s!gX!v!gX!w!gX!x!gX!y!gX!z!gX!{!gX!|!gX!}!gX#O!gX#P!gX#Q!gX#R!gX#S!gX#T!gX#U!gX#V!gX#W!gX#X!gX#Y!gX#Z!gX#[!gX#]!gX#^!gX#_!gX#`!gX#a!gX#b!gX#c!gX#d!gX#e!gX#f!gX#g!gX#h!gX#i!gX#j!gX#k!gX#l!gX#m!gX#n!gX#o!gX#p!gX#q!gX#r!gX#s!gX#t!gX#u!gX#v!gX#w!gX#x!gX#y!gX#z!gX#{!gX#|!gX#}!gX$O!gX$P!gX$Q!gX$R!gX$S!gX$T!gX$U!gX$V!gX$W!gX$X!gX$Y!gX$Z!gX$[!gX$]!gX$^!gX$_!gX$`!gX$a!gX$b!gX$c!gX$d!gX$e!gX$f!gX$g!gX$h!gX$i!gX$j!gX$k!gX$l!gX$m!gX$n!gX$o!gX$p!gX$q!gX$r!gX$s!gX$t!gX$u!gX$v!gX$w!gX$x!gX$y!gX$z!gX${!gX$|!gX$}!gX%O!gX%P!gX%Q!gX%R!gX%S!gX%T!gX%^!gX%o!gX%p!gX%q!gX%r!gX%w!gX%z!gX%|!gXq!gXt!gX!O!gX~O%d!aOQ!jX]!jX_!jXg!jXh!jXi!jXj!jXk!jXp!jXr!jXu!jXx!jXy!jXz!jX{!jX|!jX!P!jX!R!jX!T!jX!V!jX!W!jX![!jX!]!jX!^!jX!c!jX!d!jX!e!jX!h!jX!k!jX!n!jX!s!jX!v!jX!w!jX!x!jX!y!jX!z!jX!{!jX!|!jX!}!jX#O!jX#P!jX#Q!jX#R!jX#S!jX#T!jX#U!jX#V!jX#W!jX#X!jX#Y!jX#Z!jX#[!jX#]!jX#^!jX#_!jX#`!jX#a!jX#b!jX#c!jX#d!jX#e!jX#f!jX#g!jX#h!jX#i!jX#j!jX#k!jX#l!jX#m!jX#n!jX#o!jX#p!jX#q!jX#r!jX#s!jX#t!jX#u!jX#v!jX#w!jX#x!jX#y!jX#z!jX#{!jX#|!jX#}!jX$O!jX$P!jX$Q!jX$R!jX$S!jX$T!jX$U!jX$V!jX$W!jX$X!jX$Y!jX$Z!jX$[!jX$]!jX$^!jX$_!jX$`!jX$a!jX$b!jX$c!jX$d!jX$e!jX$f!jX$g!jX$h!jX$i!jX$j!jX$k!jX$l!jX$m!jX$n!jX$o!jX$p!jX$q!jX$r!jX$s!jX$t!jX$u!jX$v!jX$w!jX$x!jX$y!jX$z!jX${!jX$|!jX$}!jX%O!jX%P!jX%Q!jX%R!jX%S!jX%T!jX%^!jX%o!jX%p!jX%q!jX%r!jX%w!jX%z!jX%|!jXq!jXt!jX!O!jX~O%d!cOQ!mX]!mX_!mXg!mXh!mXi!mXj!mXk!mXp!mXr!mXu!mXx!mXy!mXz!mX{!mX|!mX!P!mX!R!mX!T!mX!V!mX!W!mX![!mX!]!mX!^!mX!c!mX!d!mX!e!mX!h!mX!k!mX!n!mX!s!mX!v!mX!w!mX!x!mX!y!mX!z!mX!{!mX!|!mX!}!mX#O!mX#P!mX#Q!mX#R!mX#S!mX#T!mX#U!mX#V!mX#W!mX#X!mX#Y!mX#Z!mX#[!mX#]!mX#^!mX#_!mX#`!mX#a!mX#b!mX#c!mX#d!mX#e!mX#f!mX#g!mX#h!mX#i!mX#j!mX#k!mX#l!mX#m!mX#n!mX#o!mX#p!mX#q!mX#r!mX#s!mX#t!mX#u!mX#v!mX#w!mX#x!mX#y!mX#z!mX#{!mX#|!mX#}!mX$O!mX$P!mX$Q!mX$R!mX$S!mX$T!mX$U!mX$V!mX$W!mX$X!mX$Y!mX$Z!mX$[!mX$]!mX$^!mX$_!mX$`!mX$a!mX$b!mX$c!mX$d!mX$e!mX$f!mX$g!mX$h!mX$i!mX$j!mX$k!mX$l!mX$m!mX$n!mX$o!mX$p!mX$q!mX$r!mX$s!mX$t!mX$u!mX$v!mX$w!mX$x!mX$y!mX$z!mX${!mX$|!mX$}!mX%O!mX%P!mX%Q!mX%R!mX%S!mX%T!mX%^!mX%o!mX%p!mX%q!mX%r!mX%w!mX%z!mX%|!mXq!mXt!mX!O!mX~O`!fOa!fOb!fOc!fOd!fOe!fOf!fO!P!eO!b!fO!c!fO!d!fO!e!fO%i!iO%j!fO~O%n!iO~P6XOR!lO%a!lO~P+ZOq!mO~PfOt!nO~PfO!O!oO~PfOQSO]YO__Og_Oh_Oi_Oj_Ok_Op_OrTOuUOxcOycOzcO{cO|cO!PVO!TdO!VeO!WeO![fO!]fO!^fO!c_O!d_O!e_O!hgO!khO!niO!s_O!v_O!wjO!xjO!yjO!zjO!{jO!|jO!}jO#OjO#PjO#QjO#RjO#SjO#TjO#UjO#VjO#WjO#XjO#YjO#ZjO#[jO#]jO#^jO#_jO#`jO#ajO#bjO#cjO#djO#ejO#fjO#gjO#hjO#ijO#jjO#kjO#ljO#mjO#njO#ojO#pjO#qjO#rjO#sjO#tjO#ujO#vjO#wjO#xjO#yjO#zjO#{jO#|jO#}jO$OjO$PjO$QjO$RjO$SjO$TjO$UjO$VjO$WjO$XjO$YjO$ZjO$[jO$]jO$^jO$_jO$`jO$ajO$bjO$cjO$djO$ejO$fjO$gjO$hjO$ijO$jjO$kjO$ljO$mjO$njO$ojO$pjO$qjO$rjO$sjO$tjO$ujO$vjO$wjO$xjO$yjO$zjO${jO$|jO$}jO%OjO%PjO%Q_O%R_O%S_O%T_O%o]O%p^O%qZO%rWO%wZO%z[O%|_O~O!R!qO~P!2`O!O!rO~PfO%n!uO~P6XO!R!xO~P7pO!O!zO%f!yO~O!O!}O~PfO!O#QO~PfO`!fOa!fOb!fOc!fOd!fOe!fOf!fO!P!eO!b!fO!c!fO!d!fO!e!fO%j!fO~O%g#SO~P!<uO!O#TO~O!R#UO~P7pO!O#VO~PfO%g#WO~P!<uOml!d!e!cp!v%Q%|%S%T~",
+  goto: ",X&OPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP&PPPP&jPP&j&PPPPPP'ZPP'^P&PP'wPP'z'}&PPPP(h(k(uPPPP(x&PP)O&PP)R&PP)U&j&P&PP&P'TPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP)X)s)y*^*hPPPPPPPPPPPPPPPPPPPPPPP*r+QP+m+{P,RP&P!P_OTUVXbcdefqsuw|!U!W!Y!^!e!s!|#O!O_OTUVXbcdefqsuw|!U!W!Y!^!e!s!|#OX}^l!P!jR!Uch`OTUVbqsu|!e!s#O[xXcde!U!WR!qwR!WdR!We!PXOTUVXbcdefqsuw|!U!W!Y!^!e!s!|#OR!^fQ!]fS!x!Y!^R#U!|R!{![X!fk!h!y#RR!`gR!bhR!diQbOQqTQsUQuV[!Rbqsu!s#OQ!s|R#O!eQnSR!kn[wXcde!U!WQ!YfU!pw!Y!|R!|!^Q!hkS#P!h#RR#R!yQ!P^Q!jlT!t!P!jiaOTUVbqsu|!e!s#Oh`OTUVbqsu|!e!s#OgvXcdefw!U!W!Y!^!|UyXdeQ!TcQ!v!UR!w!WX!gk!h!y#RX!O^l!P!j",
+  nodeNames: "⚠ BlockComment PodDirective PodDirective PodDirective PodHeading PodStrong PodEmphasis PodCode PodLink PodFormat Heredoc Heredoc . MethodName Version CharacterClass Assertion StringLiteral Operator LineComment BlockComment VariableName StringLiteral Regex Regex Operator VariableName LineComment DocComment Program Pod Number ) ( Parens ] [ Brackets PackageDeclaration class role grammar module package PackageName } { Block ; RoutineDeclaration sub RoutineName method submethod RoutineName RoutineName RegexDeclaration token rule regex RegexName Block Regex Escape VariableName AttributeName SpecialVariable Block EnumDeclaration enum EnumName SubsetDeclaration subset SubsetName ConstantDeclaration constant ConstantName MethodCall Identifier TypeName Number StringLiteral Interpolation PairKey my our has state temp let anon augment supersede unit multi proto only if elsif else unless with orwith without for while until loop repeat given when default do gather take try return next last redo proceed succeed react whenever supply emit start use need import require no is does of returns handles where will trusts hides and or not xor so andthen orelse notandthen div mod gcd lcm eq ne lt gt le ge cmp leg eqv but self True False Nil BEGIN CHECK INIT END ENTER LEAVE KEEP UNDO FIRST NEXT LAST PRE POST CATCH CONTROL QUIT CLOSE DOC Operator , : . Regex Heredoc StringLiteral",
+  maxTerm: 229,
   context: trackContext,
   nodeProps: [
-    ["openedBy", 14,"(",17,"[",27,"{"],
-    ["closedBy", 15,")",18,"]",28,"}"]
+    ["openedBy", 33,"(",36,"[",46,"{"],
+    ["closedBy", 34,")",37,"]",47,"}"]
   ],
-  skippedNodes: [0,1,2,3,10,11],
-  repeatNodeCount: 3,
-  tokenData: "!$`~R!aX^%Wpq%Wqr%{st']tu(|uv5Rvw8axy:Wyz:]z{%{{|%{|}:b}!O%{!O!P:g!P!Q%{!Q!R;V!R![=f![!]@Z!]!^FQ!^!_%{!_!`%{!`!a%{!a!b%{!b!cFV!c!}Gy!}#OJu#O#PJz#P#Q! T#Q#R%{#R#S! Y#T#o! Y#o#p!$U#p#q%{#q#r!$Z#r#s%{#y#z%W$f$g%W$p$q! Y$q$r%{${$|! Y%Q%R! Y%R%S%{%W%o! Y%o%p%{%p&a! Y&a&b%{&b#BY! Y#BY#BZ%W#BZ$IS! Y$IS$I_%W$Iz$I{%{$I|$JO%W$JT$JU%W$KV$KW%W%&Y%+t%{&/x&Et! Y&FU&FV%W&Gh;'S! Y;'S;=`!#x?&r?Bj! Y?Hw?Ic! Y?Ii?JT! Y?J`?L{! Y~%]Y$}~X^%Wpq%W#y#z%W$f$g%W#BY#BZ%W$IS$I_%W$I|$JO%W$JT$JU%W$KV$KW%W&FU&FV%WP&Qc$jPqr%{z{%{{|%{}!O%{!P!Q%{!^!_%{!_!`%{!`!a%{!a!b%{#O#P%{#Q#R%{#p#q%{#r#s%{$q$r%{%R%S%{%o%p%{&a&b%{$Iz$I{%{%&Y%+t%{~'bWY~OY'zZ!_'z!_!`(c!`#p'z#p#q(c#q;'S'z;'S;=`(]<%lO'z~(PSY~OY'zZ;'S'z;'S;=`(]<%lO'z~(`P;=`<%l'z~(jSZ~Y~OY(cZ;'S(c;'S;=`(v<%lO(c~(yP;=`<%l(c~)Rk%T~qr*vz{.|!O!P-h!P!Q1x!Q![1}![!]2V!_!`.|!a!b.|!c!}3_#Q#R2V#R#S3_#T#o3_#r#s.|$p$q3_${$|3_%Q%R3_%W%o3_%p&a3_&b#BY3_#BZ$IS3_&/x&Et3_&Gh;'S3_;'S;=`4{?&r?Bj3_?Hw?Ic3_?Ii?JT3_?J`?L{3_~*{a!V~!c!},Q#R#S,Q#T#o,Q$p$q,Q${$|,Q%Q%R,Q%W%o,Q%p&a,Q&b#BY,Q#BZ$IS,Q&/x&Et,Q&Gh;'S,Q;'S;=`.p?&r?Bj,Q?Hw?Ic,Q?Ii?JT,Q?J`?L{,Q~,Ve!W~wx-h}!O-h!Q![,Q![!].v!c!},Q#R#S,Q#T#o,Q$p$q,Q${$|,Q%Q%R,Q%W%o,Q%p&a,Q&b#BY,Q#BZ$IS,Q&/x&Et,Q&Gh;'S,Q;'S;=`.p?&r?Bj,Q?Hw?Ic,Q?Ii?JT,Q?J`?L{,Q~-ka!c!},Q#R#S,Q#T#o,Q$p$q,Q${$|,Q%Q%R,Q%W%o,Q%p&a,Q&b#BY,Q#BZ$IS,Q&/x&Et,Q&Gh;'S,Q;'S;=`.p?&r?Bj,Q?Hw?Ic,Q?Ii?JT,Q?J`?L{,Q~.sP;=`<%l,Q~.yP![!]-h~/Pa!c!}0U#R#S0U#T#o0U$p$q0U${$|0U%Q%R0U%W%o0U%p&a0U&b#BY0U#BZ$IS0U&/x&Et0U&Gh;'S0U;'S;=`1r?&r?Bj0U?Hw?Ic0U?Ii?JT0U?J`?L{0U~0Ze!X~wx.|}!O.|!Q![0U![!]1l!c!}0U#R#S0U#T#o0U$p$q0U${$|0U%Q%R0U%W%o0U%p&a0U&b#BY0U#BZ$IS0U&/x&Et0U&Gh;'S0U;'S;=`1r?&r?Bj0U?Hw?Ic0U?Ii?JT0U?J`?L{0U~1oP![!].|~1uP;=`<%l0U~1}O!V~~2SP!V~!Q![1}~2Ya!c!}3_#R#S3_#T#o3_$p$q3_${$|3_%Q%R3_%W%o3_%p&a3_&b#BY3_#BZ$IS3_&/x&Et3_&Gh;'S3_;'S;=`4{?&r?Bj3_?Hw?Ic3_?Ii?JT3_?J`?L{3_~3de!V~wx2V}!O2V!Q![3_![!]4u!c!}3_#R#S3_#T#o3_$p$q3_${$|3_%Q%R3_%W%o3_%p&a3_&b#BY3_#BZ$IS3_&/x&Et3_&Gh;'S3_;'S;=`4{?&r?Bj3_?Hw?Ic3_?Ii?JT3_?J`?L{3_~4xP![!]2V~5OP;=`<%l3_~5Wj$jPqr-huv6xz{.|!O!P-h![!]2V!_!`7V!a!b.|!c!}3_#Q#R2V#R#S3_#T#o3_#r#s.|$p$q3_${$|3_%Q%R3_%W%o3_%p&a3_&b#BY3_#BZ$IS3_&/x&Et3_&Gh;'S3_;'S;=`4{?&r?Bj3_?Hw?Ic3_?Ii?JT3_?J`?L{3_P6}P$jP!_!`7QP7VO$jP~7[a$jP!c!}0U#R#S0U#T#o0U$p$q0U${$|0U%Q%R0U%W%o0U%p&a0U&b#BY0U#BZ$IS0U&/x&Et0U&Gh;'S0U;'S;=`1r?&r?Bj0U?Hw?Ic0U?Ii?JT0U?J`?L{0U~8fj$jPqr-hvw6xz{.|!O!P-h![!]2V!_!`7V!a!b.|!c!}3_#Q#R2V#R#S3_#T#o3_#r#s.|$p$q3_${$|3_%Q%R3_%W%o3_%p&a3_&b#BY3_#BZ$IS3_&/x&Et3_&Gh;'S3_;'S;=`4{?&r?Bj3_?Hw?Ic3_?Ii?JT3_?J`?L{3_~:]O_~~:bO^~~:gO$k~~:lQ$m~!O!P:r!_!`7QP:wQ$jP!O!P:}#Q#R7QP;SP$jP#Q#R7Q~;[^![~!O!P<W!Q![=f!d!e>T!f!g>o!g!h<r!q!r?T!z!{?i#R#S=}#U#V>T#W#X>o#X#Y<r#]#^=a#c#d?T#l#m?i~<ZP!Q![<^~<cT![~!Q![<^!g!h<r#R#S<W#X#Y<r#]#^=a~<uR{|=O}!O=O!Q![=U~=RP!Q![=U~=ZQ![~!Q![=U#]#^=a~=fO![~~=kU![~!O!P<W!Q![=f!g!h<r#R#S=}#X#Y<r#]#^=a~>QP!Q![=f~>WR!Q!R>a!R!S>a#R#S>a~>fR![~!Q!R>a!R!S>a#R#S>a~>rQ!Q![>x#R#S>x~>}Q![~!Q![>x#R#S>x~?WQ!Q!Y?^#R#S?^~?cQ![~!Q!Y?^#R#S?^~?lS!Q![?x!c!i?x#R#S?x#T#Z?x~?}S![~!Q![?x!c!i?x#R#S?x#T#Z?x~@`e$l~qrAq!Q![Dm![!]Et!_!`7Q!c!}By#R#SBy#T#oBy$p$qBy${$|By%Q%RBy%W%oBy%p&aBy&b#BYBy#BZ$ISBy&/x&EtBy&Gh;'SBy;'S;=`Dg?&r?BjBy?Hw?IcBy?Ii?JTBy?J`?L{By~Ata!c!}By#R#SBy#T#oBy$p$qBy${$|By%Q%RBy%W%oBy%p&aBy&b#BYBy#BZ$ISBy&/x&EtBy&Gh;'SBy;'S;=`Dg?&r?BjBy?Hw?IcBy?Ii?JTBy?J`?L{By~COe!`~wxAq}!OAq!Q![By![!]Da!c!}By#R#SBy#T#oBy$p$qBy${$|By%Q%RBy%W%oBy%p&aBy&b#BYBy#BZ$ISBy&/x&EtBy&Gh;'SBy;'S;=`Dg?&r?BjBy?Hw?IcBy?Ii?JTBy?J`?L{By~DdP![!]Aq~DjP;=`<%lBy~DpQ!Q![Dm!^!_Dv~DyT!O!PEY!Q![EY!c!}EY#R#SEY#T#oEY~E]U!O!PEY!Q![EY!`!aEo!c!}EY#R#SEY#T#oEY~EtO]~PEwP![!]EzPE}P!_!`7Q~FVOn~~F[i%T~qr-hz{.|!O!P-h![!]2V!_!`.|!a!b.|!c!}3_#Q#R2V#R#S3_#T#o3_#r#s.|$p$q3_${$|3_%Q%R3_%W%o3_%p&a3_&b#BY3_#BZ$IS3_&/x&Et3_&Gh;'S3_;'S;=`4{?&r?Bj3_?Hw?Ic3_?Ii?JT3_?J`?L{3_~HOe%S~wxIa}!OIa!Q![Gy![!]Jo!c!}Gy#R#SGy#T#oGy$p$qGy${$|Gy%Q%RGy%W%oGy%p&aGy&b#BYGy#BZ$ISGy&/x&EtGy&Gh;'SGy;'S;=`Ji?&r?BjGy?Hw?IcGy?Ii?JTGy?J`?L{Gy~Ida!c!}Gy#R#SGy#T#oGy$p$qGy${$|Gy%Q%RGy%W%oGy%p&aGy&b#BYGy#BZ$ISGy&/x&EtGy&Gh;'SGy;'S;=`Ji?&r?BjGy?Hw?IcGy?Ii?JTGy?J`?L{Gy~JlP;=`<%lGy~JrP![!]Ia~JzOb~RKPu$jPOqMdqrMirzMdz{Mi{|Mi|}Md}!OMi!O!PMd!P!QMi!Q!^Md!^!_Mi!_!`Mi!`!aMi!a!bMi!b#OMd#O#PMi#P#QMd#Q#RMi#R#pMd#p#qMi#q#rMd#r#sMi#s$qMd$q$rMi$r%RMd%R%SMi%S%oMd%o%pMi%p&aMd&a&bMi&b$IzMd$Iz$I{Mi$I{%&YMd%&Y%+tMi%+t;'SMd;'S;=`N{;=`OMdQMiO!^QRMpc!^Q$jPqr%{z{%{{|%{}!O%{!P!Q%{!^!_%{!_!`%{!`!a%{!a!b%{#O#P%{#Q#R%{#p#q%{#r#s%{$q$r%{%R%S%{%o%p%{&a&b%{$Iz$I{%{%&Y%+t%{Q! QP!^Q;=`<%lMd~! YOa~~! _e%Q~wx!!p}!O!!p!Q![! Y![!]!$O!c!}! Y#R#S! Y#T#o! Y$p$q! Y${$|! Y%Q%R! Y%W%o! Y%p&a! Y&b#BY! Y#BZ$IS! Y&/x&Et! Y&Gh;'S! Y;'S;=`!#x?&r?Bj! Y?Hw?Ic! Y?Ii?JT! Y?J`?L{! Y~!!sa!c!}! Y#R#S! Y#T#o! Y$p$q! Y${$|! Y%Q%R! Y%W%o! Y%p&a! Y&b#BY! Y#BZ$IS! Y&/x&Et! Y&Gh;'S! Y;'S;=`!#x?&r?Bj! Y?Hw?Ic! Y?Ii?JT! Y?J`?L{! Y~!#{P;=`<%l! Y~!$RP![!]!!p~!$ZOl~~!$`Ok~",
-  tokenizers: [blockComment, podToken, heredocToken, methodDotToken, nameToken, smileyToken, versionToken, regexBodyToken, quoteToken, termToken, 0, 1],
-  topRules: {"Program":[0,12]},
-  specialized: [{term: 186, get: (value) => spec_identifier[value] || -1},{term: 188, get: (value) => spec_capIdentifier[value] || -1}],
-  tokenPrec: 3609
+  skippedNodes: [0,1,11,12,28,29],
+  repeatNodeCount: 5,
+  tokenData: "!$`~R!aX^%Wpq%Wqr%{st']tu(|uv5Rvw8axy:Wyz:]z{%{{|%{|}:b}!O%{!O!P:g!P!Q%{!Q!R;V!R![=f![!]@Z!]!^FQ!^!_%{!_!`%{!`!a%{!a!b%{!b!cFV!c!}Gy!}#OJu#O#PJz#P#Q! T#Q#R%{#R#S! Y#T#o! Y#o#p!$U#p#q%{#q#r!$Z#r#s%{#y#z%W$f$g%W$p$q! Y$q$r%{${$|! Y%Q%R! Y%R%S%{%W%o! Y%o%p%{%p&a! Y&a&b%{&b#BY! Y#BY#BZ%W#BZ$IS! Y$IS$I_%W$Iz$I{%{$I|$JO%W$JT$JU%W$KV$KW%W%&Y%+t%{&/x&Et! Y&FU&FV%W&Gh;'S! Y;'S;=`!#x?&r?Bj! Y?Hw?Ic! Y?Ii?JT! Y?J`?L{! Y~%]Y%t~X^%Wpq%W#y#z%W$f$g%W#BY#BZ%W$IS$I_%W$I|$JO%W$JT$JU%W$KV$KW%W&FU&FV%WP&Qc%QPqr%{z{%{{|%{}!O%{!P!Q%{!^!_%{!_!`%{!`!a%{!a!b%{#O#P%{#Q#R%{#p#q%{#r#s%{$q$r%{%R%S%{%o%p%{&a&b%{$Iz$I{%{%&Y%+t%{~'bWl~OY'zZ!_'z!_!`(c!`#p'z#p#q(c#q;'S'z;'S;=`(]<%lO'z~(PSl~OY'zZ;'S'z;'S;=`(]<%lO'z~(`P;=`<%l'z~(jSm~l~OY(cZ;'S(c;'S;=`(v<%lO(c~(yP;=`<%l(c~)Rk%|~qr*vz{.|!O!P-h!P!Q1x!Q![1}![!]2V!_!`.|!a!b.|!c!}3_#Q#R2V#R#S3_#T#o3_#r#s.|$p$q3_${$|3_%Q%R3_%W%o3_%p&a3_&b#BY3_#BZ$IS3_&/x&Et3_&Gh;'S3_;'S;=`4{?&r?Bj3_?Hw?Ic3_?Ii?JT3_?J`?L{3_~*{a!c~!c!},Q#R#S,Q#T#o,Q$p$q,Q${$|,Q%Q%R,Q%W%o,Q%p&a,Q&b#BY,Q#BZ$IS,Q&/x&Et,Q&Gh;'S,Q;'S;=`.p?&r?Bj,Q?Hw?Ic,Q?Ii?JT,Q?J`?L{,Q~,Ve!d~wx-h}!O-h!Q![,Q![!].v!c!},Q#R#S,Q#T#o,Q$p$q,Q${$|,Q%Q%R,Q%W%o,Q%p&a,Q&b#BY,Q#BZ$IS,Q&/x&Et,Q&Gh;'S,Q;'S;=`.p?&r?Bj,Q?Hw?Ic,Q?Ii?JT,Q?J`?L{,Q~-ka!c!},Q#R#S,Q#T#o,Q$p$q,Q${$|,Q%Q%R,Q%W%o,Q%p&a,Q&b#BY,Q#BZ$IS,Q&/x&Et,Q&Gh;'S,Q;'S;=`.p?&r?Bj,Q?Hw?Ic,Q?Ii?JT,Q?J`?L{,Q~.sP;=`<%l,Q~.yP![!]-h~/Pa!c!}0U#R#S0U#T#o0U$p$q0U${$|0U%Q%R0U%W%o0U%p&a0U&b#BY0U#BZ$IS0U&/x&Et0U&Gh;'S0U;'S;=`1r?&r?Bj0U?Hw?Ic0U?Ii?JT0U?J`?L{0U~0Ze!e~wx.|}!O.|!Q![0U![!]1l!c!}0U#R#S0U#T#o0U$p$q0U${$|0U%Q%R0U%W%o0U%p&a0U&b#BY0U#BZ$IS0U&/x&Et0U&Gh;'S0U;'S;=`1r?&r?Bj0U?Hw?Ic0U?Ii?JT0U?J`?L{0U~1oP![!].|~1uP;=`<%l0U~1}O!c~~2SP!c~!Q![1}~2Ya!c!}3_#R#S3_#T#o3_$p$q3_${$|3_%Q%R3_%W%o3_%p&a3_&b#BY3_#BZ$IS3_&/x&Et3_&Gh;'S3_;'S;=`4{?&r?Bj3_?Hw?Ic3_?Ii?JT3_?J`?L{3_~3de!c~wx2V}!O2V!Q![3_![!]4u!c!}3_#R#S3_#T#o3_$p$q3_${$|3_%Q%R3_%W%o3_%p&a3_&b#BY3_#BZ$IS3_&/x&Et3_&Gh;'S3_;'S;=`4{?&r?Bj3_?Hw?Ic3_?Ii?JT3_?J`?L{3_~4xP![!]2V~5OP;=`<%l3_~5Wj%QPqr-huv6xz{.|!O!P-h![!]2V!_!`7V!a!b.|!c!}3_#Q#R2V#R#S3_#T#o3_#r#s.|$p$q3_${$|3_%Q%R3_%W%o3_%p&a3_&b#BY3_#BZ$IS3_&/x&Et3_&Gh;'S3_;'S;=`4{?&r?Bj3_?Hw?Ic3_?Ii?JT3_?J`?L{3_P6}P%QP!_!`7QP7VO%QP~7[a%QP!c!}0U#R#S0U#T#o0U$p$q0U${$|0U%Q%R0U%W%o0U%p&a0U&b#BY0U#BZ$IS0U&/x&Et0U&Gh;'S0U;'S;=`1r?&r?Bj0U?Hw?Ic0U?Ii?JT0U?J`?L{0U~8fj%QPqr-hvw6xz{.|!O!P-h![!]2V!_!`7V!a!b.|!c!}3_#Q#R2V#R#S3_#T#o3_#r#s.|$p$q3_${$|3_%Q%R3_%W%o3_%p&a3_&b#BY3_#BZ$IS3_&/x&Et3_&Gh;'S3_;'S;=`4{?&r?Bj3_?Hw?Ic3_?Ii?JT3_?J`?L{3_~:]Or~~:bOq~~:gO%R~~:lQ%T~!O!P:r!_!`7QP:wQ%QP!O!P:}#Q#R7QP;SP%QP#Q#R7Q~;[^!s~!O!P<W!Q![=f!d!e>T!f!g>o!g!h<r!q!r?T!z!{?i#R#S=}#U#V>T#W#X>o#X#Y<r#]#^=a#c#d?T#l#m?i~<ZP!Q![<^~<cT!s~!Q![<^!g!h<r#R#S<W#X#Y<r#]#^=a~<uR{|=O}!O=O!Q![=U~=RP!Q![=U~=ZQ!s~!Q![=U#]#^=a~=fO!s~~=kU!s~!O!P<W!Q![=f!g!h<r#R#S=}#X#Y<r#]#^=a~>QP!Q![=f~>WR!Q!R>a!R!S>a#R#S>a~>fR!s~!Q!R>a!R!S>a#R#S>a~>rQ!Q![>x#R#S>x~>}Q!s~!Q![>x#R#S>x~?WQ!Q!Y?^#R#S?^~?cQ!s~!Q!Y?^#R#S?^~?lS!Q![?x!c!i?x#R#S?x#T#Z?x~?}S!s~!Q![?x!c!i?x#R#S?x#T#Z?x~@`e%S~qrAq!Q![Dm![!]Et!_!`7Q!c!}By#R#SBy#T#oBy$p$qBy${$|By%Q%RBy%W%oBy%p&aBy&b#BYBy#BZ$ISBy&/x&EtBy&Gh;'SBy;'S;=`Dg?&r?BjBy?Hw?IcBy?Ii?JTBy?J`?L{By~Ata!c!}By#R#SBy#T#oBy$p$qBy${$|By%Q%RBy%W%oBy%p&aBy&b#BYBy#BZ$ISBy&/x&EtBy&Gh;'SBy;'S;=`Dg?&r?BjBy?Hw?IcBy?Ii?JTBy?J`?L{By~COe!v~wxAq}!OAq!Q![By![!]Da!c!}By#R#SBy#T#oBy$p$qBy${$|By%Q%RBy%W%oBy%p&aBy&b#BYBy#BZ$ISBy&/x&EtBy&Gh;'SBy;'S;=`Dg?&r?BjBy?Hw?IcBy?Ii?JTBy?J`?L{By~DdP![!]Aq~DjP;=`<%lBy~DpQ!Q![Dm!^!_Dv~DyT!O!PEY!Q![EY!c!}EY#R#SEY#T#oEY~E]U!O!PEY!Q![EY!`!aEo!c!}EY#R#SEY#T#oEY~EtOp~PEwP![!]EzPE}P!_!`7Q~FVO!R~~F[i%|~qr-hz{.|!O!P-h![!]2V!_!`.|!a!b.|!c!}3_#Q#R2V#R#S3_#T#o3_#r#s.|$p$q3_${$|3_%Q%R3_%W%o3_%p&a3_&b#BY3_#BZ$IS3_&/x&Et3_&Gh;'S3_;'S;=`4{?&r?Bj3_?Hw?Ic3_?Ii?JT3_?J`?L{3_~HOe%z~wxIa}!OIa!Q![Gy![!]Jo!c!}Gy#R#SGy#T#oGy$p$qGy${$|Gy%Q%RGy%W%oGy%p&aGy&b#BYGy#BZ$ISGy&/x&EtGy&Gh;'SGy;'S;=`Ji?&r?BjGy?Hw?IcGy?Ii?JTGy?J`?L{Gy~Ida!c!}Gy#R#SGy#T#oGy$p$qGy${$|Gy%Q%RGy%W%oGy%p&aGy&b#BYGy#BZ$ISGy&/x&EtGy&Gh;'SGy;'S;=`Ji?&r?BjGy?Hw?IcGy?Ii?JTGy?J`?L{Gy~JlP;=`<%lGy~JrP![!]Ia~JzOu~RKPu%QPOqMdqrMirzMdz{Mi{|Mi|}Md}!OMi!O!PMd!P!QMi!Q!^Md!^!_Mi!_!`Mi!`!aMi!a!bMi!b#OMd#O#PMi#P#QMd#Q#RMi#R#pMd#p#qMi#q#rMd#r#sMi#s$qMd$q$rMi$r%RMd%R%SMi%S%oMd%o%pMi%p&aMd&a&bMi&b$IzMd$Iz$I{Mi$I{%&YMd%&Y%+tMi%+t;'SMd;'S;=`N{;=`OMdQMiO!bQRMpc!bQ%QPqr%{z{%{{|%{}!O%{!P!Q%{!^!_%{!_!`%{!`!a%{!a!b%{#O#P%{#Q#R%{#p#q%{#r#s%{$q$r%{%R%S%{%o%p%{&a&b%{$Iz$I{%{%&Y%+t%{Q! QP!bQ;=`<%lMd~! YOt~~! _e%w~wx!!p}!O!!p!Q![! Y![!]!$O!c!}! Y#R#S! Y#T#o! Y$p$q! Y${$|! Y%Q%R! Y%W%o! Y%p&a! Y&b#BY! Y#BZ$IS! Y&/x&Et! Y&Gh;'S! Y;'S;=`!#x?&r?Bj! Y?Hw?Ic! Y?Ii?JT! Y?J`?L{! Y~!!sa!c!}! Y#R#S! Y#T#o! Y$p$q! Y${$|! Y%Q%R! Y%W%o! Y%p&a! Y&b#BY! Y#BZ$IS! Y&/x&Et! Y&Gh;'S! Y;'S;=`!#x?&r?Bj! Y?Hw?Ic! Y?Ii?JT! Y?J`?L{! Y~!#{P;=`<%l! Y~!$RP![!]!!p~!$ZO!P~~!$`O!O~",
+  tokenizers: [smileyToken, blockComment, podToken, heredocToken, methodDotToken, nameToken, versionToken, regexToken, quoteToken, termToken, 0, 1],
+  topRules: {"Program":[0,30],"Regex":[1,190],"Heredoc":[2,191],"StringLiteral":[3,192]},
+  specialized: [{term: 223, get: (value) => spec_identifier[value] || -1},{term: 226, get: (value) => spec_capIdentifier[value] || -1}],
+  tokenPrec: 3469
 });
 
 // The keywords of the grammar, with the tag each is highlighted with.
@@ -921,6 +1700,279 @@ const keywordTags = {
     self: tags.self
 };
 
+const scopes = new NodeWeakMap();
+const scopeNodes = /^(Block|Interpolation|Program)$/;
+const variableNodes = /^(VariableName|AttributeName)$/;
+const declarators = /^(my|our|has|state)$/;
+/// Whether a variable is a placeholder, which is declared by being
+/// used: $^a, and the named $:a
+function isPlaceholder(name) { return /^[$@%&][\^:]/.test(name); }
+// The name of the variable without a sigil that the backslash `node`
+// comes right before, as in `\x`. A capitalized one reads as a type.
+function sigillessName(state, node) {
+    let next = node.nextSibling;
+    return node.name == "Operator" && next && (next.name == "Identifier" || next.name == "TypeName") &&
+        next.from == node.to && state.sliceDoc(node.from, node.to) == "\\" ? next : null;
+}
+// Whether a block is a subscript, as in %h{$key}: it touches the term
+// before it. It is not a scope for placeholder variables.
+function isSubscript(block) {
+    let prev = block.prevSibling;
+    return block.name == "Block" && prev != null && prev.to == block.from && /^[A-Z]/.test(prev.name) && prev.name != "Operator";
+}
+/// Whether a completion is for a name with a sigil.
+function hasSigil(completion) { return /^[$@%&]/.test(completion.label); }
+function variable(label) {
+    return { label, type: label[0] == "&" ? "function" : /^.[!.]/.test(label) ? "property" : "variable", boost: 1 };
+}
+function isArrow(text) { return text == "->" || text == "<->"; }
+class Gatherer {
+    constructor(state) {
+        this.state = state;
+        this.names = [];
+        this.methods = [];
+    }
+    text(node) { return this.state.sliceDoc(node.from, node.to); }
+    declare(node) {
+        let label = this.text(node);
+        // A name without a sigil: my \x
+        if (!variableNodes.test(node.name))
+            return this.names.push({ label, type: "variable", boost: 1 });
+        this.names.push(variable(label));
+        // `has $.x` also makes the private `$!x`, and `$^a` can be written `$a`.
+        if (label[1] == ".")
+            this.names.push(variable(label[0] + "!" + label.slice(2)));
+        else if (isPlaceholder(label))
+            this.names.push(variable(label[0] + label.slice(2)));
+    }
+    // Declares the name after `node`, when `node` is the backslash of a
+    // variable without a sigil: my \x = 1, sub f(\x) { }
+    declareSigilless(node) {
+        let name = sigillessName(this.state, node);
+        if (name)
+            this.declare(name);
+        return name != null;
+    }
+    // The variables of a signature, or of the parentheses of `my (...)`.
+    // What follows a `=` or a `where`, up to the next comma, is a default
+    // value or a constraint, and uses variables rather than declaring them.
+    declareAll(node) {
+        let uses = false;
+        for (let child = node.firstChild; child; child = child.nextSibling) {
+            let { name } = child;
+            if (name == ",")
+                uses = false;
+            else if (name == "where" || name == "Operator" && this.text(child) == "=")
+                uses = true;
+            else if (uses)
+                continue;
+            else if (this.declareSigilless(child))
+                continue;
+            else if (variableNodes.test(name))
+                this.declare(child);
+            else if (name == "Parens" || name == "Brackets")
+                this.declareAll(child);
+        }
+    }
+    addMethods(scope) {
+        for (let method of scopeOf(scope, this.state).methods)
+            this.methods.push(method);
+    }
+    // Goes over the content of a node that is not a scope of its own.
+    content(node) {
+        // Whether a declarator was seen, and what it declares is yet to come.
+        let declaring = false;
+        for (let child = node.firstChild; child; child = child.nextSibling) {
+            let { name } = child;
+            if (declarators.test(name)) {
+                declaring = true;
+                continue;
+            }
+            // my Int $x, my Array[Int] @y
+            if (declaring && (name == "TypeName" || name == "Brackets"))
+                continue;
+            // A placeholder variable declares itself where it is used: { $^a + $^b }
+            if (name == "VariableName" && isPlaceholder(this.text(child)))
+                this.declare(child);
+            else if (declaring && this.declareSigilless(child))
+                continue;
+            else if (declaring && variableNodes.test(name))
+                this.declare(child);
+            else if (declaring && name == "Parens")
+                this.declareAll(child);
+            else if (scopeNodes.test(name)) {
+                // The placeholders in a subscript are those of the block around it.
+                if (isSubscript(child))
+                    this.placeholders(child);
+                this.addMethods(child);
+            }
+            else if (/Declaration$/.test(name))
+                this.declaration(child);
+            else if (child.firstChild)
+                this.content(child);
+            // The name of a constant with a sigil is a variable after the
+            // declaration node: constant $LIMIT = 3
+            declaring = name == "ConstantDeclaration" && child.lastChild.name == "constant";
+        }
+    }
+    // The placeholder variables in a node, and in the subscripts in it.
+    placeholders(node) {
+        for (let child = node.firstChild; child; child = child.nextSibling) {
+            if (child.name == "VariableName") {
+                if (isPlaceholder(this.text(child)))
+                    this.declare(child);
+            }
+            else if (child.firstChild && (!scopeNodes.test(child.name) || isSubscript(child)))
+                this.placeholders(child);
+        }
+    }
+    declaration(node) {
+        let kind = node.firstChild.name;
+        for (let child = node.firstChild; child; child = child.nextSibling) {
+            let { name } = child;
+            if (name == "RoutineName") {
+                let label = this.text(child);
+                // An operator is not called by its name: infix:<+>
+                if (/:[<«\[]/.test(label))
+                    continue;
+                // `multi foo` has no declarator, and declares a sub.
+                if (kind == "sub" || kind == "RoutineName")
+                    this.names.push({ label, type: "function", boost: 1 }, variable("&" + label));
+                // A private method is called as self!name, where nothing is completed.
+                else if (/^[^!^]/.test(label))
+                    this.methods.push({ label, type: "method", boost: 1 });
+            }
+            else if (name == "PackageName") {
+                this.names.push({ label: this.text(child), type: "class", boost: 1 });
+            }
+            else if (name == "EnumName" || name == "SubsetName") {
+                this.names.push({ label: this.text(child), type: "type", boost: 1 });
+            }
+            else if (name == "ConstantName") {
+                let label = this.text(child);
+                this.names.push(/^[$@%&]/.test(label) ? variable(label) : { label, type: "constant", boost: 1 });
+            }
+            else if (scopeNodes.test(name)) {
+                this.addMethods(child);
+            }
+            else if (name != "Parens" && child.firstChild) {
+                // The signature belongs to the scope of the body.
+                this.content(child);
+            }
+        }
+    }
+    // The parameters of a block: those of the routine that it is the body
+    // of, or the ones after the arrow of a pointy block.
+    parameters(block) {
+        let parent = block.parent;
+        if (parent && parent.name == "RoutineDeclaration") {
+            for (let child = parent.firstChild; child; child = child.nextSibling)
+                if (child.name == "Parens")
+                    this.declareAll(child);
+            return;
+        }
+        // Going backwards, the variables of a parameter come before the
+        // `=` of its default value.
+        let found = [], parameter = [];
+        for (let prev = block.prevSibling; prev; prev = prev.prevSibling) {
+            let { name } = prev;
+            if (name == ";" || name == "Block" || /Declaration$/.test(name))
+                return;
+            if (name == "VariableName") {
+                parameter.push(prev);
+            }
+            else if (prev.prevSibling && sigillessName(this.state, prev.prevSibling)) {
+                // -> \item { }
+                parameter.push(prev);
+            }
+            else if (name == ",") {
+                found = found.concat(parameter);
+                parameter = [];
+            }
+            else if (name == "Operator") {
+                let text = this.text(prev);
+                if (text == "=")
+                    parameter = [];
+                else if (isArrow(text)) {
+                    for (let node of found.concat(parameter))
+                        this.declare(node);
+                    return;
+                }
+            }
+        }
+    }
+}
+// The names that the scope node `node` declares in its content. The
+// parameters of a block are not part of its node, and are left out.
+function scopeOf(node, state) {
+    let scope = scopes.get(node);
+    if (scope)
+        return scope;
+    let gatherer = new Gatherer(state);
+    gatherer.content(node);
+    scope = { names: gatherer.names, methods: gatherer.methods };
+    scopes.set(node, scope);
+    return scope;
+}
+/// The names that are in scope at `node`, innermost scope first, and
+/// the methods of the whole document.
+function localNames(node, state) {
+    let names = [], methods = [];
+    for (let cur = node; cur; cur = cur.parent) {
+        if (!scopeNodes.test(cur.name))
+            continue;
+        let scope = scopeOf(cur, state);
+        // An edit to the parameters does not replace the block's node, so
+        // these are read every time.
+        let parameters = new Gatherer(state);
+        parameters.parameters(cur);
+        for (let name of parameters.names)
+            names.push(name);
+        for (let name of scope.names)
+            names.push(name);
+        methods = scope.methods;
+    }
+    return { names, methods };
+}
+/// Whether a variable is in a place where variables are declared, so
+/// that its name is a new one. The variable is a child of `parent`, and
+/// comes after the sibling `prev`.
+function declaresVariable(state, parent, prev) {
+    let text = (node) => state.sliceDoc(node.from, node.to);
+    // A signature, or the list of `my ($a, $b)`, unless the variable is
+    // in a default value or in a constraint.
+    if (parent.name == "Parens") {
+        let before = parent.prevSibling;
+        if (parent.parent && parent.parent.name == "RoutineDeclaration" || before && declarators.test(before.name)) {
+            for (let node = prev; node && node.name != ","; node = node.prevSibling)
+                if (node.name == "where" || node.name == "Operator" && text(node) == "=")
+                    return false;
+            return true;
+        }
+    }
+    // After a declarator, or after the arrow of a pointy block.
+    let first = true;
+    for (let node = prev; node; node = node.prevSibling) {
+        let { name } = node;
+        // `my $a, $b` declares the first one only.
+        if (declarators.test(name))
+            return first;
+        if (name == ";" || name == "Block" || name == "{" || /Declaration$/.test(name))
+            return false;
+        if (name == "Operator") {
+            let operator = text(node);
+            if (isArrow(operator))
+                return true;
+            if (operator == "=")
+                return false;
+        }
+        // Only a type can stand between a declarator and its variable.
+        if (name != "TypeName" && name != "Brackets")
+            first = false;
+    }
+    return false;
+}
+
 function completions(type, ...labels) {
     return labels.join(" ").split(" ").map(label => ({ label, type }));
 }
@@ -937,6 +1989,7 @@ const globals = [...keywords, ...constants, ...types, ...routines];
 // `:key` is not a name from the list.
 const nameTail = /^(\w[\w:'\-]*)?$/;
 const specialVariableTail = /^[$@%&][*?][\w\-]*$/;
+const variableTail = /^[$@%&][!.^:]?[\w'\-]*$/;
 // Whether the position of `node` holds code, as opposed to the text of
 // a string, a regex, a comment or Pod. An interpolation is code again.
 function inCode(node) {
@@ -963,8 +2016,26 @@ function isPrivateMethodName(tree, state, node) {
     return invocant.to == mark.from &&
         /^(self|VariableName|AttributeName|SpecialVariable|Identifier|TypeName|Parens|Brackets|[)\]])$/.test(invocant.name);
 }
-/// A completion source for Raku keywords and for the commonly used
-/// built-in types, routines, methods and special variables.
+// The names declared in the document, followed by the built-in ones
+// that they do not hide.
+function withLocal(local, builtin) {
+    if (!local.length)
+        return builtin;
+    let labels = new Set(), result = [];
+    for (let completion of local) {
+        if (labels.has(completion.label))
+            continue;
+        labels.add(completion.label);
+        result.push(completion);
+    }
+    for (let completion of builtin)
+        if (!labels.has(completion.label))
+            result.push(completion);
+    return result;
+}
+/// A completion source for Raku keywords, for the commonly used
+/// built-in types, routines, methods and special variables, and for the
+/// names that the document declares.
 const rakuCompletionSource = context => {
     let { state, pos } = context, tree = syntaxTree(state), node = tree.resolveInner(pos, -1);
     if (!inCode(node))
@@ -973,46 +2044,337 @@ const rakuCompletionSource = context => {
     let special = node.name == "SpecialVariable" ? node : context.matchBefore(/[$@%&][*?]$/);
     if (special)
         return { from: special.from, options: specialVariables, validFor: specialVariableTail };
+    // A variable, or a sigil that is about to be one. A lone `%` or `&`
+    // is as often an operator, and has to be followed by a name first.
+    let isVariableNode = node.name == "VariableName" || node.name == "AttributeName";
+    let sigil = isVariableNode ? null : context.matchBefore(/[$@]$|[$@%&][!.^:]$/);
+    if (isVariableNode || sigil) {
+        let from = isVariableNode ? node.from : sigil.from;
+        // A lone sigil is not a node. It lies in the node around it.
+        let parent = isVariableNode ? node.parent : tree.resolveInner(from, 0);
+        let prev = isVariableNode ? node.prevSibling : parent.childBefore(from);
+        if (declaresVariable(state, parent, prev))
+            return null;
+        // A placeholder variable is declared by being used, also by the
+        // one that is being typed, which is not offered for itself.
+        let typed = isVariableNode ? state.sliceDoc(from, node.to) : "";
+        let options = withLocal(localNames(parent, state).names.filter(hasSigil), []);
+        if (isPlaceholder(typed))
+            options = options.filter(completion => completion.label != typed);
+        return options.length ? { from, options, validFor: variableTail } : null;
+    }
+    let local = localNames(node, state), localMethods = () => withLocal(local.methods, methods);
     if (node.name == "MethodName")
-        return { from: node.from, options: methods, validFor: nameTail };
+        return { from: node.from, options: localMethods(), validFor: nameTail };
     // A dot or `.=` with no name after it yet. Two dots are a range operator.
     let before = state.sliceDoc(Math.max(0, pos - 2), pos);
     if (before == ".=")
-        return { from: pos, options: methods, validFor: nameTail };
+        return { from: pos, options: localMethods(), validFor: nameTail };
     if (/(^|[^.])\.$/.test(before)) {
         // The dot of `1.5` and of `v6.d` is far more often typed than a
         // method call on a number.
         let numeric = /^(Number|Version)$/.test(tree.resolveInner(pos - 1, -1).name);
-        return numeric && !context.explicit ? null : { from: pos, options: methods, validFor: nameTail };
+        return numeric && !context.explicit ? null : { from: pos, options: localMethods(), validFor: nameTail };
     }
+    let localGlobals = () => withLocal(local.names.filter(completion => !hasSigil(completion)), globals);
     // A keyword's node is named after the keyword, as are those of `,` and `;`.
     let isKeyword = /^\w/.test(node.name) && node.name == state.sliceDoc(node.from, node.to);
     if (isKeyword || node.name == "Identifier" || node.name == "TypeName") {
         if (isPrivateMethodName(tree, state, node))
             return null;
-        // `$x .= trim` calls a method.
         let prev = node.prevSibling;
+        // The name of a variable without a sigil, where it is declared: my \x
+        if (prev && prev.to == node.from && state.sliceDoc(prev.from, prev.to) == "\\" &&
+            declaresVariable(state, node.parent, prev.prevSibling))
+            return null;
+        // `$x .= trim` calls a method.
         let afterDotAssign = prev != null && prev.name == "Operator" && state.sliceDoc(prev.from, prev.to) == ".=";
-        return { from: node.from, options: afterDotAssign ? methods : globals, validFor: nameTail };
+        return { from: node.from, options: afterDotAssign ? localMethods() : localGlobals(), validFor: nameTail };
     }
-    // Other names (variables, pair keys, names being declared) are made up
-    // by the user, so only a position where no token has been started
-    // gets the whole list, and only on request.
+    // Other names (pair keys, names being declared) are made up by the
+    // user, so only a position where no token has been started gets the
+    // whole list, and only on request.
     if (context.explicit && /^[\s(\[{,;=]?$/.test(state.sliceDoc(Math.max(0, pos - 1), pos)))
-        return { from: pos, options: globals, validFor: nameTail };
+        return { from: pos, options: localGlobals(), validFor: nameTail };
     return null;
 };
 
+// The grammar has no statement nodes, so whether a line continues the
+// statement before it is worked out here, from the token that precedes
+// the line and from what the line starts with.
+const skipped = /^(LineComment|DocComment|BlockComment|Pod|Heredoc)$/;
+const brackets = /^(Block|Parens|Brackets|Interpolation|Program)$/;
+const wordOperators = /^(and|or|xor|andthen|orelse|notandthen|div|mod|gcd|lcm|eq|ne|lt|gt|le|ge|cmp|leg|eqv|but)$/;
+// Operators that end a term or stand for a whole statement.
+const closingOperators = /^(\+\+|--|\.\.\.|!!!|\?\?\?)$/;
+// The words that start a trait. `of` is left out: it is as often a
+// name of one's own.
+const traits = "is|does|returns|handles|where|will";
+/// The lines that are indented again when they are typed: one that
+/// closes a bracket, and one that starts with a trait, which is only
+/// known to continue a statement once the trait's word is there.
+const indentOnInput = new RegExp("^\\s*(?:[\\}\\]\\)]|(?:" + traits + ")\\s)$");
+// A line that starts with an infix: an operator that has a space after
+// it and more on the line, an operator that is a word, a statement
+// modifier, or a trait (`is export`). A prefix operator touches its
+// operand, and `...` stands alone.
+const startsWithInfix = new RegExp("^\\s*(?:[~+\\-*/%<>=|&^?!]+[ \\t]+\\S|(?:" + wordOperators.source.slice(2, -2) +
+    "|if|unless|for|while|until|given|when|with|without" +
+    "|" + traits + ")(?![\\w'-]))");
+const startsWithMethod = /^\s*\.[^\s\d.]/;
+// The last token of `node`. A string, a regex, a heredoc and a Pod
+// block count as one token: what they end in is not code.
+const wholeTokens = /^(StringLiteral|Regex|Heredoc|Pod)$/;
+function lastToken(node) {
+    while (node.lastChild && !wholeTokens.test(node.name))
+        node = node.lastChild;
+    return node;
+}
+// The last token that ends at or before `pos` in `bracket`, not
+// counting comments.
+function tokenBefore(bracket, pos) {
+    let node = bracket.resolveInner(pos, -1);
+    // Either the node that ends there, or the one around the position.
+    if (node.to > pos)
+        node = node.childBefore(pos);
+    while (node) {
+        let token = lastToken(node);
+        if (!skipped.test(token.name))
+            return token;
+        // Go to what comes before the comment, in this node or around it.
+        while (node && !node.prevSibling)
+            node = node.parent;
+        node = node && node.prevSibling;
+    }
+    return null;
+}
+function bracketAround(node) {
+    for (let parent = node.parent; parent; parent = parent.parent)
+        if (brackets.test(parent.name))
+            return parent;
+    return null;
+}
+// The bracket node whose content a token is part of. The brackets of a
+// node are part of the content around that node.
+function bracketOf(token) {
+    let around = bracketAround(token);
+    return around && around == token.parent && /^[()\[\]{}]$/.test(token.name) ? bracketAround(around) : around;
+}
+// The first node after `node` that is not a comment.
+function nextCode(node) {
+    do
+        node = node && node.nextSibling;
+    while (node && skipped.test(node.name));
+    return node;
+}
+// Whether a block in braces holds the pairs of a hash, in which a comma
+// separates items that line up.
+function holdsPairs(block, state) {
+    let first = block.name == "Block" ? nextCode(block.firstChild) : null;
+    if (!first)
+        return false;
+    if (first.name == "PairKey")
+        return true;
+    let second = nextCode(first);
+    return second != null && second.name == "Operator" && state.sliceDoc(second.from, second.to) == "=>";
+}
+// Whether a line continues a statement of `bracket`. The line starts at
+// `pos` with the text `after`.
+function continuesStatement(state, bracket, pos, after) {
+    // The lines of a regex are not statements: its `+` and `|` are not
+    // the operators of an expression.
+    for (let node = bracket.resolveInner(pos, -1); node && node.from >= bracket.from; node = node.parent) {
+        if (node.name == "Regex")
+            return false;
+        if (brackets.test(node.name))
+            break;
+    }
+    let before = tokenBefore(bracket, pos);
+    if (!before || bracketOf(before) != bracket)
+        return false;
+    let name = before.name, text = state.sliceDoc(before.from, before.to);
+    if (name == "Operator")
+        return !closingOperators.test(text);
+    if (wordOperators.test(name) && name == text)
+        return true;
+    if (name == ",")
+        return !holdsPairs(bracket, state);
+    if (name == ";" || name == "{")
+        return false;
+    if (name == "}") {
+        // A block ends its statement. A subscript, which touches the term
+        // that it follows, does not: %h{$key}
+        let block = before.parent;
+        return block.from > 0 && !/\s/.test(state.sliceDoc(block.from - 1, block.from)) && startsWithInfix.test(after);
+    }
+    // After the end of a statement, a `.` calls a method on the topic.
+    return startsWithInfix.test(after) || startsWithMethod.test(after);
+}
+// Whether the content of a bracket node starts on the line of its
+// opening bracket, which `delimitedIndent` then aligns the rest with.
+function isAligned(node, state) {
+    let open = node.firstChild, next = nextCode(open);
+    return open != null && next != null && next != node.lastChild && next.from < state.doc.lineAt(open.from).to;
+}
+const bodyKeywords = /^(if|elsif|else|unless|with|orwith|without|for|while|until|loop|repeat|given|when|default|whenever|react|supply|gather|do|try|start)$/;
+const declarationPrefixes = /^(my|our|has|state|anon|augment|supersede|unit|multi|proto|only)$/;
+// The first node of the statement that a block is the body of, when it
+// is the body of a control statement or of a declaration. A block that
+// is a term in an expression has none: `my $f = sub { ... }`
+function statementOfBody(block, state) {
+    let declaration = block.parent && /Declaration$/.test(block.parent.name) ? block.parent : null;
+    let first = declaration || block;
+    for (let prev = first.prevSibling; prev; prev = prev.prevSibling) {
+        if (skipped.test(prev.name))
+            continue;
+        if (prev.name == ";" || prev.name == "{")
+            break;
+        // A closing brace that is followed by a line break ends a statement.
+        if (lastToken(prev).name == "}" && /\n/.test(state.sliceDoc(prev.to, first.from)))
+            break;
+        if (declaration && !declarationPrefixes.test(prev.name))
+            return null;
+        first = prev;
+    }
+    return declaration || bodyKeywords.test(first.name) ? first : null;
+}
+/// The indentation of the lines in a node that holds statements between
+/// braces: that of `delimitedIndent`, and one unit more for a line that
+/// continues a statement.
+function statementIndent(closing) {
+    let delimited = delimitedIndent({ closing });
+    return (context) => {
+        let { node, state, unit } = context, after = context.textAfter;
+        let closed = after.slice(/^\s*/.exec(after)[0].length).startsWith(closing);
+        // The body of a statement is indented from the line where the
+        // statement starts, which need not be the line of its brace.
+        //   if $a
+        //     && $b {
+        //     say 1;
+        //   }
+        let statement = isAligned(node, state) ? null : statementOfBody(node, state);
+        let indent = statement ? context.lineIndent(statement.from) + (closed ? 0 : unit) : delimited(context);
+        return !closed && continuesStatement(state, node, context.pos, after) ? indent + unit : indent;
+    };
+}
+/// The indentation of the lines at the top level.
+function topIndent(context) {
+    return continuesStatement(context.state, context.node, context.pos, context.textAfter) ? context.unit : 0;
+}
+
+function closing(open) { return String.fromCharCode(brackets$1[open.charCodeAt(0)]); }
+// The brackets to try, in this order. A bracket that is repeated has
+// to be closed as many times.
+const pairs = ["(", "[", "{", "<", "«", "「", "((", "[[", "{{", "(((", "[[[", "{{{"].map(open => {
+    return { open, close: closing(open).repeat(open.length) };
+});
+// Whether `text` can stand between the delimiters: none of them is
+// left open in it, and none closes more than were opened.
+function fits(text, { open, close }) {
+    let depth = 0;
+    for (let pos = 0; pos < text.length;) {
+        if (text.startsWith(close, pos)) {
+            if (--depth < 0)
+                return false;
+            pos += close.length;
+        }
+        else if (text.startsWith(open, pos)) {
+            depth++;
+            pos += open.length;
+        }
+        else {
+            pos++;
+        }
+    }
+    return depth == 0;
+}
+// The delimiters of the comment that a block comment command would
+// remove for the range, if there is one: the range is that comment, or
+// all of its text, give or take whitespace.
+function commentAt(state, from, to) {
+    let start = from + /^\s*/.exec(state.sliceDoc(from, to))[0].length;
+    let node = syntaxTree(state).resolveInner(start, 1);
+    if (node.name != "BlockComment")
+        return null;
+    let text = state.sliceDoc(node.from, node.to), open = /^#`(.)\1*/.exec(text);
+    if (!open || brackets$1[open[1].charCodeAt(0)] == null)
+        return null;
+    let close = closing(open[1]).repeat(open[0].length - 2);
+    if (!text.endsWith(close))
+        return null;
+    let blank = (a, b) => a >= b || !/\S/.test(state.sliceDoc(a, b));
+    let isComment = start == node.from && blank(node.to, to);
+    let isContent = blank(node.from + open[0].length, from) && blank(to, node.to - close.length) && to <= node.to;
+    return isComment || isContent ? { open: open[0], close } : null;
+}
+function blockTokens(state, pos) {
+    // The command asks at the start of what it works on, which is a
+    // selection range, or the first text of a selected line.
+    let range = state.selection.ranges.find(range => range.from == pos);
+    let existing = range && commentAt(state, range.from, range.to);
+    if (existing)
+        return existing;
+    // The command that goes by lines wraps up to the end of the line, so
+    // the brackets have to fit that text as well.
+    let texts = [], line = state.doc.lineAt(pos);
+    if (range) {
+        texts.push(state.sliceDoc(range.from, range.to));
+        line = state.doc.lineAt(range.to);
+    }
+    else {
+        let onLine = state.selection.ranges.find(range => range.from <= pos && range.from >= line.from);
+        if (onLine)
+            line = state.doc.lineAt(onLine.to);
+    }
+    if (!range || range.to < line.to)
+        texts.push(state.sliceDoc(pos, line.to));
+    // The spaces keep a bracket at the edge of the text from joining the delimiters.
+    let pair = pairs.find(pair => texts.every(text => fits(" " + text + " ", pair))) || pairs[0];
+    return { open: "#`" + pair.open, close: pair.close };
+}
+/// Language data that gives `language` block comment tokens which fit
+/// the selection. It takes precedence over the fixed tokens in the
+/// language's own data.
+function embeddedCommentTokens(language) {
+    return Prec.high(EditorState.languageData.of((state, pos, side) => {
+        if (!language.isActiveAt(state, pos, side))
+            return [];
+        // Only worked out when asked for: this is called for every kind of
+        // language data, and the line comment commands do not read `block`.
+        return [{ get commentTokens() {
+                    return { line: "#", get block() { return blockTokens(state, pos); } };
+                } }];
+    }));
+}
+
+// A regex literal is one token to the parser of a program: whether it
+// is closed has to be known where it starts, and a token that is read
+// piece by piece cannot look that far ahead (see AGENTS.md). Its inside
+// is parsed by the same grammar, from the top rule for a regex literal,
+// and that tree takes the place of the token's node. The inner parser
+// is made from `base` so that it has the same props, among them the
+// language data that LRLanguage.define puts on top nodes.
+function nestedParsers(base) {
+    // From the term of a token to the parser of its inside. The
+    // generator registers a top rule under its node name.
+    let parsers = new Map();
+    let wrap = parseMixed(node => parsers.get(node.type.id) || null);
+    // The inner parsers are wrapped as well: a regex can hold a block of
+    // code, and that can hold a regex.
+    parsers.set(regexLiteral, { parser: base.configure({ top: "Regex", wrap }) });
+    parsers.set(interpolatingHeredoc, { parser: base.configure({ top: "Heredoc", wrap }) });
+    parsers.set(interpolatingWordList, { parser: base.configure({ top: "StringLiteral", wrap }) });
+    return wrap;
+}
 /// The Lezer parser for Raku, without the editor-specific node props.
-const parser = parser$1;
-/// A language provider based on the Lezer Raku parser, extended with
-/// highlighting and indentation information.
-const rakuLanguage = LRLanguage.define({
+const parser = parser$1.configure({ wrap: nestedParsers(parser$1) });
+const baseLanguage = LRLanguage.define({
     name: "raku",
-    parser: parser.configure({
+    parser: parser$1.configure({
         props: [
             indentNodeProp.add({
-                "Block Interpolation": delimitedIndent({ closing: "}" }),
+                Program: topIndent,
+                "Block Interpolation": statementIndent("}"),
                 Parens: delimitedIndent({ closing: ")" }),
                 Brackets: delimitedIndent({ closing: "]" }),
                 // The lines of these are text, which keeps its indentation.
@@ -1026,22 +2388,30 @@ const rakuLanguage = LRLanguage.define({
                 // A heredoc starts with the line break before its first line.
                 Heredoc(tree) { return { from: tree.from, to: tree.to }; }
             }),
-            styleTags(Object.assign(Object.assign({}, keywordTags), { "True False": tags.bool, Nil: tags.null, Identifier: tags.function(tags.variableName), TypeName: tags.typeName, PackageName: tags.definition(tags.className), "EnumName SubsetName": tags.definition(tags.typeName), ConstantName: tags.definition(tags.constant(tags.variableName)), "RoutineName RegexName": tags.function(tags.definition(tags.variableName)), MethodName: tags.function(tags.propertyName), VariableName: tags.variableName, AttributeName: tags.propertyName, SpecialVariable: tags.special(tags.variableName), PairKey: tags.attributeName, Number: tags.number, Version: tags.literal, "StringLiteral Heredoc": tags.string, Regex: tags.regexp, Pod: tags.docComment, Escape: tags.escape, "Interpolation/{ Interpolation/}": tags.special(tags.brace), LineComment: tags.lineComment, BlockComment: tags.blockComment, DocComment: tags.docComment, Operator: tags.operator, ".": tags.derefOperator, ", ;": tags.separator, ":": tags.punctuation, "( )": tags.paren, "[ ]": tags.squareBracket, "{ }": tags.brace }))
+            styleTags(Object.assign(Object.assign({}, keywordTags), { "True False": tags.bool, Nil: tags.null, Identifier: tags.function(tags.variableName), TypeName: tags.typeName, PackageName: tags.definition(tags.className), "EnumName SubsetName": tags.definition(tags.typeName), ConstantName: tags.definition(tags.constant(tags.variableName)), "RoutineName RegexName": tags.function(tags.definition(tags.variableName)), MethodName: tags.function(tags.propertyName), VariableName: tags.variableName, AttributeName: tags.propertyName, SpecialVariable: tags.special(tags.variableName), PairKey: tags.attributeName, Number: tags.number, Version: tags.literal, "StringLiteral Heredoc": tags.string, Regex: tags.regexp, CharacterClass: tags.character, Assertion: tags.function(tags.variableName), "Pod PodFormat": tags.docComment, PodDirective: tags.meta, 
+                // These are still part of a comment, and are styled as one where
+                // a theme has no style for the second tag.
+                PodHeading: [tags.docComment, tags.heading], PodStrong: [tags.docComment, tags.strong], PodEmphasis: [tags.docComment, tags.emphasis], PodCode: [tags.docComment, tags.monospace], PodLink: [tags.docComment, tags.link], Escape: tags.escape, "Interpolation/{ Interpolation/}": tags.special(tags.brace), LineComment: tags.lineComment, BlockComment: tags.blockComment, DocComment: tags.docComment, Operator: tags.operator, ".": tags.derefOperator, ", ;": tags.separator, ":": tags.punctuation, "( )": tags.paren, "[ ]": tags.squareBracket, "{ }": tags.brace }))
         ]
     }),
     languageData: {
         // An embedded comment can use any bracket. Parentheses are the usual choice.
         commentTokens: { line: "#", block: { open: "#`(", close: ")" } },
         closeBrackets: { brackets: ["(", "[", "{", "'", '"', "「"] },
-        indentOnInput: /^\s*[\}\]\)]$/
+        indentOnInput
     }
 });
-/// Completion of Raku keywords and of the commonly used built-in types,
-/// routines, methods and special variables.
+/// A language provider based on the Lezer Raku parser, extended with
+/// highlighting and indentation information.
+const rakuLanguage = baseLanguage.configure({ wrap: nestedParsers(baseLanguage.parser) });
+/// Completion of Raku keywords, of the commonly used built-in types,
+/// routines, methods and special variables, and of the names that the
+/// document declares.
 const rakuCompletion = rakuLanguage.data.of({ autocomplete: rakuCompletionSource });
-/// Raku language support, with completion.
+/// Raku language support, with completion, and with block comment
+/// tokens that fit the selection.
 function raku() {
-    return new LanguageSupport(rakuLanguage, [rakuCompletion]);
+    return new LanguageSupport(rakuLanguage, [rakuCompletion, embeddedCommentTokens(rakuLanguage)]);
 }
 
 export { parser, raku, rakuCompletion, rakuLanguage };