Method takeUntil

Extension/src/Utility/Text/scanner.ts:597–639

(endToken: Kind, options?: { escape?: Kind[]; nestable?: [Kind, Kind][] }, yieldFinalClose?: boolean)

    }

    *takeUntil(endToken: Kind, options?: { escape?: Kind[]; nestable?: [Kind, Kind][] }, yieldFinalClose?: boolean): Iterable<Token> {
        const nestable = options?.nestable || [];
        const escape = options?.escape || [];

        processing: do {
            switch (this.kind) {
                case endToken:
                    // if we're nested, we need to return the end token, because it's significant to the consumer
                    if (yieldFinalClose) {
                        yield this.take();
                        return;
                    }

                    // we're done here, lose the last token and get out
                    this.take();
                    return;

                case Kind.EndOfFile:
                    throw new Error('Unexpected end of tokens');
            }

            // check for escaped tokens
            if (escape.includes(this.kind)) {
                // pull through the escape token
                // and the next token
                yield this.take();
                yield this.take();
                continue;
            }

            // check for nested tokens
            for (const [open, close] of nestable as [Kind, Kind][]) {
                if (this.kind === open) {
                    yield this.take(); // yield the open token
                    yield* this.takeUntil(close, options, true);
                    continue processing;
                }
            }

            // yield the current token
            yield this.take();
        } while (true);
    }

    takeWhitespace() {
        while (!this.eof && this.isWhitespace) {