tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/astnav.js

@@ -0,0 +1,767 @@
+// Finding nodes and tokens at positions of a source file, like tsgo's astnav.
+import { getComment, JSDocParameterOrPropertyTag, NodeVisitor, Token, } from './ast.js';
+import { isPropertyNameLiteral } from './binder-utilities.js';
+import { nodeIsMissing } from './ast-utilities.js';
+import { getJSDoc } from './parser.js';
+import { Scanner, skipTrivia } from './scanner.js';
+/** The property name or token touching `position`. */
+export function getTouchingPropertyName(file, position) {
+    return findTokenAtPosition(file, position, false, true);
+}
+/** The token touching `position`. */
+export function getTouchingToken(file, position) {
+    return findTokenAtPosition(file, position, false, false);
+}
+/** Whether a token ending at a touched position counts as touching it. */
+function isTouchingPropertyName(node) {
+    return isPropertyNameLiteral(node) || isKeywordKind(node.kind) || node.kind === 80 /* SyntaxKind.PrivateIdentifier */;
+}
+function isKeywordKind(kind) {
+    return kind >= 82 /* SyntaxKind.FirstKeyword */ && kind <= 166 /* SyntaxKind.LastKeyword */;
+}
+function isTokenKind(kind) {
+    return kind >= 0 /* SyntaxKind.FirstToken */ && kind <= 166 /* SyntaxKind.LastToken */;
+}
+function isJSDocKind(kind) {
+    return kind >= 308 /* SyntaxKind.FirstJSDocNode */ && kind <= 343 /* SyntaxKind.LastJSDocNode */;
+}
+function isReparsed(node) {
+    return (node.flags & 8 /* NodeFlags.Reparsed */) !== 0;
+}
+function isWhitespaceOnlyJsxText(node) {
+    return node.kind === 11 /* SyntaxKind.JsxText */ && node.containsOnlyTriviaWhiteSpaces;
+}
+function isNonWhitespaceToken(node) {
+    return isTokenKind(node.kind) && !isWhitespaceOnlyJsxText(node);
+}
+function isJsxChild(node) {
+    switch (node.kind) {
+        case 285 /* SyntaxKind.JsxElement */:
+        case 295 /* SyntaxKind.JsxExpression */:
+        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+        case 11 /* SyntaxKind.JsxText */:
+        case 289 /* SyntaxKind.JsxFragment */:
+            return true;
+    }
+    return false;
+}
+/** JSDoc nodes whose trivia isn't made of tokens. */
+function shouldSkipChild(node) {
+    const kind = node.kind;
+    return (kind === 315 /* SyntaxKind.JSDoc */ ||
+        kind === 316 /* SyntaxKind.JSDocText */ ||
+        kind === 317 /* SyntaxKind.JSDocTypeLiteral */ ||
+        kind === 318 /* SyntaxKind.JSDocSignature */ ||
+        kind === 319 /* SyntaxKind.JSDocLink */ ||
+        kind === 320 /* SyntaxKind.JSDocLinkCode */ ||
+        kind === 321 /* SyntaxKind.JSDocLinkPlain */ ||
+        (kind >= 322 /* SyntaxKind.FirstJSDocTagNode */ && kind <= 343 /* SyntaxKind.LastJSDocTagNode */));
+}
+/** A lone JSDoc comment node, which navigation treats as part of its parent's text. */
+function isSingleCommentList(list) {
+    if (list.nodes.length !== 1)
+        return false;
+    const parent = list.nodes[0].parent;
+    return parent !== undefined && isJSDocKind(parent.kind) && getComment(parent) === list;
+}
+/** The start of a node's first token, optionally including its JSDoc. */
+export function getTokenPosOfNode(node, file, includeJSDoc) {
+    // Missing nodes have no width; skipping trivia would move to the next token.
+    if (nodeIsMissing(node))
+        return node.pos;
+    // JSX text can't contain comments, though the scanner would see them.
+    if (isJSDocKind(node.kind) || node.kind === 11 /* SyntaxKind.JsxText */)
+        return skipTrivia(file.text, node.pos, false, true, false);
+    if (includeJSDoc) {
+        const jsDoc = getJSDoc(file, node);
+        if (jsDoc.length > 0)
+            return getTokenPosOfNode(jsDoc[0], file, false);
+    }
+    return skipTrivia(file.text, node.pos, false, false, (node.flags & 4194304 /* NodeFlags.JSDoc */) !== 0);
+}
+/** Visits the JSDoc and then the children of a node, in the order navigation expects. */
+function visitChildrenAndJSDoc(node, file, visitor) {
+    const jsDoc = getJSDoc(file, node);
+    for (let i = 0; i < jsDoc.length; i++)
+        visitor.visitNode(jsDoc[i]);
+    if (node instanceof JSDocParameterOrPropertyTag) {
+        // The tag name, the name, then the type, wherever the type is written.
+        visitor.visitNode(node.tagName);
+        visitor.visitNode(node.name);
+        if (node.typeExpression !== undefined)
+            visitor.visitNode(node.typeExpression);
+        if (node.comment !== undefined)
+            visitor.visitList(node.comment);
+        return;
+    }
+    node.forEachChild(visitor);
+}
+let navigationScanner;
+let navigationScannerFile;
+/** A scanner positioned on the token at `pos`. */
+function getScannerAt(file, pos) {
+    let scanner = navigationScanner;
+    if (scanner === undefined) {
+        scanner = new Scanner();
+        navigationScanner = scanner;
+    }
+    if (navigationScannerFile !== file) {
+        scanner.setText(file.text);
+        scanner.setLanguageVariant(file.languageVariant);
+        navigationScannerFile = file;
+    }
+    scanner.resetTokenState(pos);
+    scanner.scan();
+    return scanner;
+}
+function scanNavigationToken(scanner, containingNode) {
+    const token = scanner.getToken();
+    if (token === 47 /* SyntaxKind.LessThanLessThanToken */ && isJsxChild(containingNode))
+        return scanner.reScanJsxToken(true);
+    return token;
+}
+// Tokens made from the scanner, by parent and range, so repeated lookups in a file give the
+// same node. Only the most recently navigated file is cached.
+let tokenCacheFile;
+let tokenCache = new Map();
+/** Forgets the file the navigation scanner and token cache last visited. */
+export function forgetNavigationFile() {
+    navigationScanner = undefined;
+    navigationScannerFile = undefined;
+    tokenCacheFile = undefined;
+    tokenCache = new Map();
+}
+/** A token the parser doesn't store, made from the scanner's current token. */
+function createToken(kind, pos, end, parent) {
+    const file = navigationScannerFile;
+    if (file !== tokenCacheFile) {
+        tokenCacheFile = file;
+        tokenCache = new Map();
+    }
+    let byRange = tokenCache.get(parent);
+    if (byRange === undefined) {
+        byRange = new Map();
+        tokenCache.set(parent, byRange);
+    }
+    const key = pos * 0x4000000 + (end - pos);
+    const cached = byRange.get(key);
+    if (cached !== undefined && cached.kind === kind)
+        return cached;
+    const token = new Token(kind);
+    token.pos = pos | 0;
+    token.end = end | 0;
+    token.parent = parent;
+    byRange.set(key, token);
+    return token;
+}
+// Finds the child of the current node that contains the target position.
+class TokenAtPositionVisitor extends NodeVisitor {
+    file;
+    position;
+    allowPositionInLeadingTrivia;
+    includePrecedingToken;
+    /** The child to descend into. */
+    next = undefined;
+    /** A child ending at the position, whose last token may touch it. */
+    prevSubtree = undefined;
+    /** The lower bound of the token to return; where scanning starts. */
+    left = 0;
+    /** The first child after the one that moved `left`; scanning stops at its start. */
+    nodeAfterLeft = undefined;
+    constructor(file, position, allowPositionInLeadingTrivia, includePrecedingToken) {
+        super();
+        this.file = file;
+        this.position = position;
+        this.allowPositionInLeadingTrivia = allowPositionInLeadingTrivia;
+        this.includePrecedingToken = includePrecedingToken;
+    }
+    /** -1 if `node` ends before the position, 1 if it starts after it, 0 if it contains it. */
+    testNode(node) {
+        const position = this.position;
+        if (node.kind !== 1 /* SyntaxKind.EndOfFile */ && node.end === position && this.includePrecedingToken && !isReparsed(node))
+            this.prevSubtree = node;
+        // Nodes at the end of the file contain their end, since there's nowhere else to look.
+        if (node.end < position ||
+            (node.end === position &&
+                node.kind !== 1 /* SyntaxKind.EndOfFile */ &&
+                (!isJSDocKind(node.kind) || node.end !== this.file.endOfFileToken.end)))
+            return -1;
+        const start = this.allowPositionInLeadingTrivia ? node.pos : getTokenPosOfNode(node, this.file, true);
+        return start > this.position ? 1 : 0;
+    }
+    visitNode(node) {
+        if (isReparsed(node) || isSingleCommentNode(node))
+            return false;
+        if (this.nodeAfterLeft === undefined)
+            this.nodeAfterLeft = node;
+        if (this.next === undefined) {
+            const result = this.testNode(node);
+            if (result < 0) {
+                // `left` can't move into JSDoc: a token after it is scanned with all its leading trivia.
+                if (!isJSDocKind(node.kind))
+                    this.left = node.end;
+                this.nodeAfterLeft = undefined;
+            }
+            else if (result === 0)
+                this.next = node;
+        }
+        return false;
+    }
+    visitList(list) {
+        const nodes = list.nodes;
+        if (nodes.length === 0 || isSingleCommentList(list))
+            return false;
+        if (this.nodeAfterLeft === undefined) {
+            for (let i = 0; i < nodes.length; i++)
+                if (!isReparsed(nodes[i])) {
+                    this.nodeAfterLeft = nodes[i];
+                    break;
+                }
+        }
+        if (this.next !== undefined)
+            return false;
+        const position = this.position;
+        if (list.end === position && this.includePrecedingToken) {
+            this.left = list.end;
+            this.nodeAfterLeft = undefined;
+            for (let i = nodes.length - 1; i >= 0; i--)
+                if (!isReparsed(nodes[i])) {
+                    this.prevSubtree = nodes[i];
+                    break;
+                }
+        }
+        else if (list.end <= position) {
+            this.left = list.end;
+            this.nodeAfterLeft = undefined;
+        }
+        else if (list.pos <= position) {
+            let index = this.searchList(nodes, true);
+            let candidates = nodes;
+            if (index >= 0 && isReparsed(nodes[index])) {
+                candidates = nodes.filter((node) => !isReparsed(node));
+                index = this.searchList(candidates, false);
+            }
+            if (index >= 0)
+                this.next = candidates[index];
+        }
+        return false;
+    }
+    visitModifiers(list) {
+        return this.visitList(list);
+    }
+    /** The index of the node containing the position, or -1. */
+    searchList(nodes, skipReparsed) {
+        let low = 0;
+        let high = nodes.length - 1;
+        while (low <= high) {
+            const middle = low + ((high - low) >> 1);
+            const node = nodes[middle];
+            if (skipReparsed && isReparsed(node))
+                return middle;
+            const cmp = this.testNode(node);
+            if (cmp < 0) {
+                this.left = node.end;
+                this.nodeAfterLeft = undefined;
+                for (let i = middle + 1; i < nodes.length; i++)
+                    if (!skipReparsed || !isReparsed(nodes[i])) {
+                        this.nodeAfterLeft = nodes[i];
+                        break;
+                    }
+                low = middle + 1;
+            }
+            else if (cmp > 0)
+                high = middle - 1;
+            else
+                return middle;
+        }
+        return -1;
+    }
+}
+/** Whether `node` is the only comment of a JSDoc node. */
+function isSingleCommentNode(node) {
+    const parent = node.parent;
+    if (parent === undefined || !isJSDocKind(parent.kind))
+        return false;
+    const comment = getComment(parent);
+    return comment !== undefined && comment.nodes.length === 1 && comment.nodes[0] === node;
+}
+/**
+ * The token at `position`: a node of the tree, or a token made from the scanner. Without
+ * `allowPositionInLeadingTrivia`, a position in trivia gives the innermost node containing it.
+ * With `includePrecedingToken`, a property name or keyword ending at `position` also counts.
+ */
+function findTokenAtPosition(file, position, allowPositionInLeadingTrivia, includePrecedingToken) {
+    let current = file;
+    const visitor = new TokenAtPositionVisitor(file, position, allowPositionInLeadingTrivia, includePrecedingToken);
+    for (;;) {
+        visitChildrenAndJSDoc(current, file, visitor);
+        // A subtree ending at the position: its last token may touch it.
+        const prevSubtree = visitor.prevSubtree;
+        if (prevSubtree !== undefined) {
+            const child = findPrecedingTokenIn(file, position, prevSubtree, false);
+            if (child !== undefined && child.end === position && isTouchingPropertyName(child))
+                return child;
+            visitor.prevSubtree = undefined;
+        }
+        const next = visitor.next;
+        if (next === undefined) {
+            // As deep as the tree goes: either a token, or one the scanner has to make.
+            if (isTokenKind(current.kind) || shouldSkipChild(current))
+                return current;
+            let left = visitor.left;
+            const scanner = getScannerAt(file, left);
+            // Scan only up to the next child, so a position between two children finds nothing.
+            const end = visitor.nodeAfterLeft !== undefined ? visitor.nodeAfterLeft.pos : current.end;
+            while (left < end) {
+                const token = scanNavigationToken(scanner, current);
+                const tokenFullStart = scanner.getTokenFullStart();
+                const tokenStart = allowPositionInLeadingTrivia ? tokenFullStart : scanner.getTokenStart();
+                const tokenEnd = scanner.getTokenEnd();
+                if (tokenEnd > end)
+                    break;
+                if (tokenStart <= position && position < tokenEnd) {
+                    if (token === 79 /* SyntaxKind.Identifier */ || !isTokenKind(token)) {
+                        if (isJSDocKind(current.kind))
+                            return current;
+                        throw new Error('did not expect ' + current.kind + ' to have ' + token + ' in its trivia');
+                    }
+                    return createToken(token, tokenFullStart, tokenEnd, current);
+                }
+                if (includePrecedingToken && tokenEnd === position) {
+                    const prevToken = createToken(token, tokenFullStart, tokenEnd, current);
+                    if (isTouchingPropertyName(prevToken))
+                        return prevToken;
+                }
+                left = tokenEnd;
+                scanner.scan();
+            }
+            return current;
+        }
+        current = next;
+        visitor.left = current.pos;
+        visitor.nodeAfterLeft = undefined;
+        visitor.next = undefined;
+    }
+}
+// Finds the leftmost child ending after the position, and the last child before it.
+class PrecedingChildVisitor extends NodeVisitor {
+    position;
+    found = undefined;
+    prev = undefined;
+    constructor(position) {
+        super();
+        this.position = position;
+    }
+    visitNode(node) {
+        if (isReparsed(node) || isSingleCommentNode(node) || this.found !== undefined)
+            return false;
+        if (this.position < node.end && (this.prev === undefined || this.prev.end <= this.position))
+            this.found = node;
+        else
+            this.prev = node;
+        return false;
+    }
+    visitList(list) {
+        const nodes = list.nodes;
+        if (this.found !== undefined || nodes.length === 0 || isSingleCommentList(list))
+            return false;
+        const position = this.position;
+        let low = 0;
+        let high = nodes.length - 1;
+        let index = -1;
+        while (low <= high) {
+            const middle = low + ((high - low) >> 1);
+            let cmp;
+            // Reparsed JSDoc nodes come before the nodes they were made for.
+            if (isReparsed(nodes[middle]))
+                cmp = -1;
+            else if (position < nodes[middle].end) {
+                cmp = middle === 0 || position >= nodes[middle - 1].end ? 0 : 1;
+            }
+            else
+                cmp = -1;
+            if (cmp < 0)
+                low = middle + 1;
+            else if (cmp > 0)
+                high = middle - 1;
+            else {
+                index = middle;
+                break;
+            }
+        }
+        if (index >= 0)
+            this.found = nodes[index];
+        const lookup = index >= 0 ? index - 1 : nodes.length - 1;
+        for (let i = lookup; i >= 0; i--) {
+            if (isReparsed(nodes[i]))
+                continue;
+            if (this.prev === undefined)
+                this.prev = nodes[i];
+        }
+        return false;
+    }
+    visitModifiers(list) {
+        return this.visitList(list);
+    }
+}
+/**
+ * The leftmost token ending after `position`; if that token is invalid or `position` is in
+ * its trivia, the rightmost valid token ending at or before `position`.
+ */
+export function findPrecedingToken(file, position) {
+    return findPrecedingTokenIn(file, position, file, false);
+}
+function findPrecedingTokenIn(file, position, startNode, excludeJSDoc) {
+    let n = startNode;
+    for (;;) {
+        if (isNonWhitespaceToken(n) && n.kind !== 1 /* SyntaxKind.EndOfFile */)
+            return n;
+        const visitor = new PrecedingChildVisitor(position);
+        visitChildrenAndJSDoc(n, file, visitor);
+        const foundChild = visitor.found;
+        if (foundChild !== undefined) {
+            // A position before the child's tokens, or a child without tokens, looks in earlier children.
+            const start = getTokenPosOfNode(foundChild, file, !excludeJSDoc);
+            const lookInPreviousChild = start >= position || !isValidPrecedingNode(foundChild, file);
+            if (!lookInPreviousChild) {
+                n = foundChild;
+                continue;
+            }
+            if (position >= foundChild.pos) {
+                // JSDoc preceding the child.
+                let jsDoc;
+                const nodeJSDoc = getJSDoc(file, n);
+                for (let i = nodeJSDoc.length - 1; i >= 0; i--)
+                    if (nodeJSDoc[i].pos >= foundChild.pos) {
+                        jsDoc = nodeJSDoc[i];
+                        break;
+                    }
+                if (jsDoc !== undefined) {
+                    if (!excludeJSDoc && position < jsDoc.end) {
+                        n = jsDoc;
+                        continue;
+                    }
+                    return findRightmostValidToken(jsDoc.end, file, n, position, excludeJSDoc);
+                }
+                return findRightmostValidToken(foundChild.pos, file, n, -1, excludeJSDoc);
+            }
+            // Between two visited children.
+            return findRightmostValidToken(foundChild.pos, file, n, position, excludeJSDoc);
+        }
+        // At the end of the file, or in the unvisited trailing tokens of `n`.
+        return findRightmostValidToken(n.end, file, n, position >= n.end ? -1 : position, excludeJSDoc);
+    }
+}
+function isValidPrecedingNode(node, file) {
+    if (node.kind === 1 /* SyntaxKind.EndOfFile */)
+        return getJSDoc(file, node).length > 0;
+    const start = getTokenPosOfNode(node, file, false);
+    return !(isWhitespaceOnlyJsxText(node) || node.end - start === 0);
+}
+// Collects the rightmost valid child and the children visited after it.
+class RightmostChildVisitor extends NodeVisitor {
+    file;
+    endPos;
+    position;
+    excludeJSDoc;
+    rightmostValid = undefined;
+    /** Children after the rightmost valid one. */
+    rightmostVisited = [];
+    hasChildren = false;
+    constructor(file, endPos, position, excludeJSDoc) {
+        super();
+        this.file = file;
+        this.endPos = endPos;
+        this.position = position;
+        this.excludeJSDoc = excludeJSDoc;
+    }
+    /** Whether `node` is in the searched range. */
+    shouldVisit(node) {
+        return !(isReparsed(node) ||
+            node.end > this.endPos ||
+            getTokenPosOfNode(node, this.file, !this.excludeJSDoc) >= this.position);
+    }
+    visitNode(node) {
+        if (isReparsed(node) || isSingleCommentNode(node))
+            return false;
+        this.hasChildren = true;
+        if (!this.shouldVisit(node))
+            return false;
+        this.rightmostVisited.push(node);
+        if (isValidPrecedingNode(node, this.file)) {
+            this.rightmostValid = node;
+            this.rightmostVisited = [];
+        }
+        return false;
+    }
+    visitList(list) {
+        const nodes = list.nodes;
+        if (nodes.length === 0 || isSingleCommentList(list))
+            return false;
+        this.hasChildren = true;
+        // The first node ending after `endPos`.
+        let low = 0;
+        let high = nodes.length - 1;
+        while (low <= high) {
+            const middle = low + ((high - low) >> 1);
+            if (nodes[middle].end > this.endPos)
+                high = middle - 1;
+            else
+                low = middle + 1;
+        }
+        const index = low;
+        let validIndex = -1;
+        for (let i = index - 1; i >= 0; i--) {
+            if (!this.shouldVisit(nodes[i]))
+                continue;
+            if (isValidPrecedingNode(nodes[i], this.file)) {
+                validIndex = i;
+                this.rightmostValid = nodes[i];
+                break;
+            }
+        }
+        for (let i = validIndex + 1; i < index; i++)
+            if (this.shouldVisit(nodes[i]))
+                this.rightmostVisited.push(nodes[i]);
+        return false;
+    }
+    visitModifiers(list) {
+        return this.visitList(list);
+    }
+}
+/**
+ * The rightmost valid token in `[containingNode.pos, endPos)`; with `position` >= 0, the
+ * rightmost one that precedes or touches it.
+ */
+function findRightmostValidToken(endPos, file, containingNode, position, excludeJSDoc) {
+    if (position === -1)
+        position = containingNode.end;
+    let n = containingNode;
+    while (n !== undefined) {
+        if (isNonWhitespaceToken(n))
+            return n;
+        const visitor = new RightmostChildVisitor(file, endPos, position, excludeJSDoc);
+        visitChildrenAndJSDoc(n, file, visitor);
+        const rightmostValid = visitor.rightmostValid;
+        // The answer may be an unvisited token after the rightmost valid child. JSDoc nodes
+        // don't have trivia tokens.
+        if (!shouldSkipChild(n)) {
+            let startPos = rightmostValid !== undefined ? rightmostValid.end : n.pos;
+            const scanner = getScannerAt(file, startPos);
+            const tokens = [];
+            const visited = visitor.rightmostVisited;
+            for (let i = 0; i < visited.length; i++) {
+                const visitedNode = visited[i];
+                // Tokens before this child.
+                while (startPos < Math.min(visitedNode.pos, position)) {
+                    const token = scanNavigationToken(scanner, n);
+                    if (scanner.getTokenStart() >= position)
+                        break;
+                    const tokenEnd = scanner.getTokenEnd();
+                    tokens.push(createToken(token, scanner.getTokenFullStart(), tokenEnd, n));
+                    startPos = tokenEnd;
+                    scanner.scan();
+                }
+                startPos = visitedNode.end;
+                scanner.resetPos(startPos);
+                scanner.scan();
+            }
+            // Tokens after the last visited child.
+            while (startPos < Math.min(endPos, position)) {
+                const token = scanNavigationToken(scanner, n);
+                if (scanner.getTokenStart() >= position)
+                    break;
+                const tokenEnd = scanner.getTokenEnd();
+                tokens.push(createToken(token, scanner.getTokenFullStart(), tokenEnd, n));
+                startPos = tokenEnd;
+                scanner.scan();
+            }
+            for (let i = tokens.length - 1; i >= 0; i--)
+                if (!isWhitespaceOnlyJsxText(tokens[i]))
+                    return tokens[i];
+        }
+        // A childless node without tokens is the answer itself.
+        if (!visitor.hasChildren)
+            return n !== containingNode ? n : undefined;
+        // Otherwise the answer is in the rightmost valid child.
+        if (rightmostValid !== undefined)
+            endPos = rightmostValid.end;
+        n = rightmostValid;
+    }
+    return undefined;
+}
+/** The token at `position`, counting leading trivia as part of the token that follows it. */
+export function getTokenAtPosition(file, position) {
+    return findTokenAtPosition(file, position, true, false);
+}
+/** Like `findPrecedingToken`, searching from `startNode`. */
+export function findPrecedingTokenEx(file, position, startNode, excludeJSDoc) {
+    return findPrecedingTokenIn(file, position, startNode ?? file, excludeJSDoc);
+}
+/** The start of a node's first token. */
+export function getStartOfNode(node, file, includeJSDoc) {
+    return getTokenPosOfNode(node, file, includeJSDoc);
+}
+// Collects the children of a node, skipping reparsed nodes and lone JSDoc comments.
+class ChildListVisitor extends NodeVisitor {
+    children = [];
+    visitNode(node) {
+        if (!isReparsed(node) && !isSingleCommentNode(node))
+            this.children.push(node);
+        return false;
+    }
+    visitList(list) {
+        if (isSingleCommentList(list))
+            return false;
+        const nodes = list.nodes;
+        for (let i = 0; i < nodes.length; i++)
+            if (!isReparsed(nodes[i]))
+                this.children.push(nodes[i]);
+        return false;
+    }
+    visitModifiers(list) {
+        return this.visitList(list);
+    }
+}
+/** The JSDoc and children of a node that navigation visits, in order. */
+export function getVisitedChildren(node, file) {
+    const visitor = new ChildListVisitor();
+    visitChildrenAndJSDoc(node, file, visitor);
+    return visitor.children;
+}
+/** The last visited child of a node; tokens the parser doesn't store aren't included. */
+export function getLastVisitedChild(node, file) {
+    const children = getVisitedChildren(node, file);
+    return children.length > 0 ? children[children.length - 1] : undefined;
+}
+/** The last child of a node, including tokens the parser doesn't store. */
+export function getLastChild(node, file) {
+    const lastChildNode = getLastVisitedChild(node, file);
+    if (lastChildNode === undefined && isSingleCommentNode(node))
+        return undefined;
+    const tokenStartPos = lastChildNode !== undefined ? lastChildNode.end : node.pos;
+    let lastToken;
+    if (tokenStartPos < node.end) {
+        const scanner = getScannerAt(file, tokenStartPos);
+        for (let startPos = tokenStartPos; startPos < node.end;) {
+            const tokenEnd = scanner.getTokenEnd();
+            lastToken = createToken(scanner.getToken(), scanner.getTokenFullStart(), tokenEnd, node);
+            startPos = tokenEnd;
+            scanner.scan();
+        }
+    }
+    return lastToken ?? lastChildNode;
+}
+/** The last token of a node; undefined for tokens and identifiers. */
+export function getLastToken(node, file) {
+    if (node === undefined || isTokenKind(node.kind))
+        return undefined;
+    const lastChild = getLastChild(node, file);
+    if (lastChild === undefined)
+        return undefined;
+    return isTokenKind(lastChild.kind) ? lastChild : getLastToken(lastChild, file);
+}
+// Finds the first child of a node.
+class FirstChildVisitor extends NodeVisitor {
+    first = undefined;
+    visitNode(node) {
+        this.first = node;
+        return true;
+    }
+}
+/** The first token of a node; undefined for tokens and identifiers. */
+export function getFirstToken(node, file) {
+    if (isTokenKind(node.kind))
+        return undefined;
+    const visitor = new FirstChildVisitor();
+    if ((node.flags & 8 /* NodeFlags.Reparsed */) === 0)
+        node.forEachChild(visitor);
+    const firstChild = visitor.first;
+    const tokenEndPosition = firstChild !== undefined ? firstChild.pos : node.end;
+    if (node.pos < tokenEndPosition) {
+        const scanner = getScannerAt(file, node.pos);
+        return createToken(scanner.getToken(), scanner.getTokenFullStart(), scanner.getTokenEnd(), node);
+    }
+    if (firstChild === undefined)
+        return undefined;
+    return isTokenKind(firstChild.kind) ? firstChild : getFirstToken(firstChild, file);
+}
+// Collects a node's children without filtering, for scanning the tokens between them.
+class AllChildrenVisitor extends NodeVisitor {
+    children = [];
+    visitNode(node) {
+        this.children.push(node);
+        return false;
+    }
+}
+/** The first child or token of `kind` in a node. */
+export function findChildOfKind(containingNode, kind, file) {
+    let lastNodePos = containingNode.pos;
+    const scanner = getScannerAt(file, lastNodePos);
+    const visitor = new AllChildrenVisitor();
+    const jsDoc = getJSDoc(file, containingNode);
+    for (let i = 0; i < jsDoc.length; i++)
+        visitor.children.push(jsDoc[i]);
+    containingNode.forEachChild(visitor);
+    const children = visitor.children;
+    for (let i = 0; i < children.length; i++) {
+        const node = children[i];
+        if (isReparsed(node))
+            continue;
+        for (let startPos = lastNodePos; startPos < node.pos;) {
+            const tokenEnd = scanner.getTokenEnd();
+            if (scanner.getToken() === kind)
+                return createToken(kind, scanner.getTokenFullStart(), tokenEnd, containingNode);
+            startPos = tokenEnd;
+            scanner.scan();
+        }
+        if (node.kind === kind)
+            return node;
+        lastNodePos = node.end;
+        scanner.resetTokenState(lastNodePos);
+        scanner.scan();
+    }
+    for (let startPos = lastNodePos; startPos < containingNode.end;) {
+        const tokenEnd = scanner.getTokenEnd();
+        if (scanner.getToken() === kind)
+            return createToken(kind, scanner.getTokenFullStart(), tokenEnd, containingNode);
+        startPos = tokenEnd;
+        scanner.scan();
+    }
+    return undefined;
+}
+/** The nodes of a list and the tokens between them, such as separating commas. */
+export function getTokensOfNodeList(list, parent, file) {
+    const tokens = [];
+    const nodes = list.nodes;
+    let left = list.pos;
+    let index = 0;
+    while (left < list.end) {
+        if (index < nodes.length && left === nodes[index].pos) {
+            tokens.push(nodes[index]);
+            left = nodes[index].end;
+            index++;
+        }
+        else {
+            const scanner = getScannerAt(file, left);
+            const tokenEnd = scanner.getTokenEnd();
+            tokens.push(createToken(scanner.getToken(), scanner.getTokenFullStart(), tokenEnd, parent));
+            left = tokenEnd;
+        }
+    }
+    return tokens;
+}
+/** The tokens in `[startPos, endPos)` of `parent`'s text, made from the scanner. */
+export function scanTokens(parent, startPos, endPos, file) {
+    const tokens = [];
+    if (startPos >= endPos)
+        return tokens;
+    const scanner = getScannerAt(file, startPos);
+    for (let pos = startPos; pos < endPos;) {
+        const tokenEnd = scanner.getTokenEnd();
+        tokens.push(createToken(scanner.getToken(), scanner.getTokenFullStart(), tokenEnd, parent));
+        pos = tokenEnd;
+        scanner.scan();
+    }
+    return tokens;
+}