xmlui 0.11.3 → 0.11.6

package/dist/scripts/src/parsers/xmlui-parser/parser.js

@@ -1,626 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createXmlUiParser = createXmlUiParser;
-exports.parseXmlUiMarkup = parseXmlUiMarkup;
-const syntax_node_1 = require("./syntax-node");
-const CharacterCodes_1 = require("./CharacterCodes");
-const scanner_1 = require("./scanner");
-const syntax_kind_1 = require("./syntax-kind");
-const utils_1 = require("./utils");
-const diagnostics_1 = require("./diagnostics");
-const RECOVER_FILE = [syntax_kind_1.SyntaxKind.CData, syntax_kind_1.SyntaxKind.Script, syntax_kind_1.SyntaxKind.OpenNodeStart];
-const RECOVER_OPEN_TAG = [
-    syntax_kind_1.SyntaxKind.OpenNodeStart,
-    syntax_kind_1.SyntaxKind.NodeEnd,
-    syntax_kind_1.SyntaxKind.NodeClose,
-    syntax_kind_1.SyntaxKind.CloseNodeStart,
-    syntax_kind_1.SyntaxKind.CData,
-    syntax_kind_1.SyntaxKind.Script,
-];
-const RECOVER_ATTR = [syntax_kind_1.SyntaxKind.Identifier, ...RECOVER_OPEN_TAG];
-const RECOVER_CONTENT_LIST = [
-    syntax_kind_1.SyntaxKind.TextNode,
-    syntax_kind_1.SyntaxKind.StringLiteral,
-    syntax_kind_1.SyntaxKind.CData,
-    syntax_kind_1.SyntaxKind.Script,
-    syntax_kind_1.SyntaxKind.OpenNodeStart,
-    syntax_kind_1.SyntaxKind.CloseNodeStart,
-];
-const RECOVER_CLOSE_TAG = [
-    syntax_kind_1.SyntaxKind.NodeEnd,
-    syntax_kind_1.SyntaxKind.OpenNodeStart,
-    syntax_kind_1.SyntaxKind.CloseNodeStart,
-    syntax_kind_1.SyntaxKind.CData,
-    syntax_kind_1.SyntaxKind.Script,
-];
-const needsExtendedContext = [
-    diagnostics_1.ErrCodes.unexpectedCloseTag,
-    diagnostics_1.ErrCodes.expCloseStartWithName,
-    diagnostics_1.ErrCodes.expCloseStart,
-    diagnostics_1.ErrCodes.tagNameMismatch,
-    diagnostics_1.ErrCodes.expEnd,
-    diagnostics_1.ErrCodes.expTagName,
-    diagnostics_1.ErrCodes.expTagOpen,
-    diagnostics_1.ErrCodes.expEndOrClose,
-    diagnostics_1.ErrCodes.expTagNameAfterNamespace,
-    diagnostics_1.ErrCodes.expTagNameAfterCloseStart,
-];
-function createXmlUiParser(source) {
-    return {
-        parse: () => parseXmlUiMarkup(source),
-        getText: (n, ignoreTrivia = true) => { var _a, _b, _c, _d; return source.substring(ignoreTrivia ? ((_b = (_a = n.pos) !== null && _a !== void 0 ? _a : n.start) !== null && _b !== void 0 ? _b : 0) : ((_d = (_c = n.start) !== null && _c !== void 0 ? _c : n.pos) !== null && _d !== void 0 ? _d : 0), n.end); },
-    };
-}
-function parseXmlUiMarkup(text) {
-    const errors = [];
-    const parents = [];
-    let peekedToken;
-    let node = { children: [] };
-    let errFromScanner = undefined;
-    const onScannerErr = function (message, length) {
-        errFromScanner = {
-            message,
-            prefixLength: length,
-        };
-    };
-    const scanner = (0, scanner_1.createScanner)(false, text, onScannerErr);
-    const fileContentListNode = parseFile();
-    return { node: fileContentListNode, errors };
-    function getText(n, ignoreTrivia = true) {
-        return text.substring(ignoreTrivia ? n.pos : n.start, n.end);
-    }
-    function parseFile() {
-        while (true) {
-            const token = peekInContent();
-            switch (token.kind) {
-                case syntax_kind_1.SyntaxKind.EndOfFileToken:
-                    bumpAny();
-                    return createNode(syntax_kind_1.SyntaxKind.ContentListNode, node.children);
-                case syntax_kind_1.SyntaxKind.CData:
-                case syntax_kind_1.SyntaxKind.Script:
-                    bumpAny();
-                    break;
-                case syntax_kind_1.SyntaxKind.OpenNodeStart:
-                    parseOpeningTag();
-                    break;
-                case syntax_kind_1.SyntaxKind.CloseNodeStart: {
-                    const errNode = errNodeUntil(RECOVER_FILE);
-                    errorAt(diagnostics_1.DIAGS.unexpectedCloseTag, errNode.pos, errNode.end);
-                    break;
-                }
-                default:
-                    const errNode = errNodeUntil(RECOVER_FILE);
-                    errorAt(diagnostics_1.DIAGS.expTagOpen, errNode.pos, errNode.end);
-                    break;
-            }
-        }
-    }
-    function parseContentList() {
-        startNode();
-        loop: while (true) {
-            const token = peekInContent();
-            switch (token.kind) {
-                case syntax_kind_1.SyntaxKind.TextNode:
-                case syntax_kind_1.SyntaxKind.StringLiteral:
-                case syntax_kind_1.SyntaxKind.CData:
-                case syntax_kind_1.SyntaxKind.Script:
-                    bumpAny();
-                    break;
-                case syntax_kind_1.SyntaxKind.OpenNodeStart:
-                    parseOpeningTag();
-                    break;
-                case syntax_kind_1.SyntaxKind.CloseNodeStart:
-                case syntax_kind_1.SyntaxKind.EndOfFileToken:
-                    break loop;
-                default:
-                    const errNode = errNodeUntil(RECOVER_CONTENT_LIST);
-                    errorAt(diagnostics_1.DIAGS.expTagOpen, errNode.pos, errNode.end);
-                    break;
-            }
-        }
-        if (node.children && node.children.length > 0) {
-            completeNode(syntax_kind_1.SyntaxKind.ContentListNode);
-        }
-        else {
-            abandonNode();
-        }
-    }
-    function parseOpeningTag() {
-        startNode();
-        bump(syntax_kind_1.SyntaxKind.OpenNodeStart);
-        let errInName = true;
-        let openTagName = null;
-        if (at(syntax_kind_1.SyntaxKind.Identifier)) {
-            const tagNameParseRes = parseOpeningTagName();
-            errInName = tagNameParseRes.errInName;
-            openTagName = tagNameParseRes.node;
-        }
-        else {
-            const errNode = errNodeUntil(RECOVER_OPEN_TAG);
-            if (errNode) {
-                errorAt(diagnostics_1.DIAGS.expTagName, errNode.pos, errNode.end);
-            }
-            else {
-                error(diagnostics_1.DIAGS.expTagName);
-            }
-        }
-        if (!errInName) {
-            parseAttrList();
-        }
-        switch (peek().kind) {
-            case syntax_kind_1.SyntaxKind.NodeClose: {
-                bumpAny();
-                completeNode(syntax_kind_1.SyntaxKind.ElementNode);
-                return;
-            }
-            case syntax_kind_1.SyntaxKind.NodeEnd: {
-                bumpAny();
-                parseContentList();
-                parseClosingTag(openTagName, errInName);
-                completeNode(syntax_kind_1.SyntaxKind.ElementNode);
-                return;
-            }
-            default: {
-                completeNode(syntax_kind_1.SyntaxKind.ElementNode);
-                error(diagnostics_1.DIAGS.expEndOrClose);
-                return;
-            }
-        }
-    }
-    function parseOpeningTagName() {
-        startNode();
-        const identNode = bump(syntax_kind_1.SyntaxKind.Identifier);
-        if (eat(syntax_kind_1.SyntaxKind.Colon) && !eat(syntax_kind_1.SyntaxKind.Identifier)) {
-            const nameNodeWithColon = completeNode(syntax_kind_1.SyntaxKind.TagNameNode);
-            const namespaceName = getText(identNode);
-            errorAt(diagnostics_1.DIAGS.expTagNameAfterNamespace(namespaceName), nameNodeWithColon.pos, nameNodeWithColon.end);
-            errNodeUntil([syntax_kind_1.SyntaxKind.Identifier, ...RECOVER_OPEN_TAG]);
-            return { node: nameNodeWithColon, errInName: true };
-        }
-        else {
-            return { node: completeNode(syntax_kind_1.SyntaxKind.TagNameNode), errInName: false };
-        }
-    }
-    function parseAttrList() {
-        startNode();
-        const attrNames = [];
-        loop: while (true) {
-            switch (peek().kind) {
-                case syntax_kind_1.SyntaxKind.EndOfFileToken:
-                // same as RECOVER_OPEN_TAG
-                case syntax_kind_1.SyntaxKind.OpenNodeStart:
-                case syntax_kind_1.SyntaxKind.NodeEnd:
-                case syntax_kind_1.SyntaxKind.NodeClose:
-                case syntax_kind_1.SyntaxKind.CloseNodeStart:
-                case syntax_kind_1.SyntaxKind.CData:
-                case syntax_kind_1.SyntaxKind.Script:
-                    break loop;
-                default:
-                    parseAttr(attrNames);
-            }
-        }
-        if (node.children.length === 0) {
-            abandonNode();
-        }
-        else {
-            completeNode(syntax_kind_1.SyntaxKind.AttributeListNode);
-        }
-    }
-    function parseAttr(attrNames) {
-        startNode();
-        if (at(syntax_kind_1.SyntaxKind.Identifier)) {
-            parseAttrName(attrNames);
-        }
-        else {
-            const errNode = errNodeUntil(RECOVER_ATTR);
-            if (errNode) {
-                if (at(syntax_kind_1.SyntaxKind.Equal)) {
-                    errorAt(diagnostics_1.DIAGS.expAttrNameBeforeEq, errNode.pos, errNode.end);
-                }
-                else {
-                    errorAt(diagnostics_1.DIAGS.expAttrName, errNode.pos, errNode.end);
-                }
-                completeNode(syntax_kind_1.SyntaxKind.AttributeNode);
-            }
-            else {
-                abandonNode();
-                error(diagnostics_1.DIAGS.expAttrName);
-            }
-            return;
-        }
-        if (eat(syntax_kind_1.SyntaxKind.Equal)) {
-            if (!eat(syntax_kind_1.SyntaxKind.StringLiteral)) {
-                const errNode = errNodeUntil(RECOVER_ATTR);
-                if (errNode) {
-                    errorAt(diagnostics_1.DIAGS.expAttrStr, errNode.pos, errNode.end);
-                }
-                else {
-                    error(diagnostics_1.DIAGS.expAttrStr);
-                }
-            }
-        }
-        completeNode(syntax_kind_1.SyntaxKind.AttributeNode);
-    }
-    function parseAttrName(attrNames) {
-        let nameIdent = peek();
-        let nsIdent = undefined;
-        startNode();
-        bump(syntax_kind_1.SyntaxKind.Identifier);
-        if (eat(syntax_kind_1.SyntaxKind.Colon)) {
-            if (at(syntax_kind_1.SyntaxKind.Identifier)) {
-                nsIdent = nameIdent;
-                nameIdent = bump(syntax_kind_1.SyntaxKind.Identifier);
-            }
-            else {
-                const namespaceName = getText(nameIdent);
-                const errNode = errNodeUntil([
-                    syntax_kind_1.SyntaxKind.Equal,
-                    syntax_kind_1.SyntaxKind.Identifier,
-                    ...RECOVER_OPEN_TAG,
-                ]);
-                if (errNode) {
-                    errorAt(diagnostics_1.DIAGS.expAttrNameAfterNamespace(namespaceName), errNode.pos, errNode.end);
-                }
-                else {
-                    error(diagnostics_1.DIAGS.expAttrNameAfterNamespace(namespaceName));
-                }
-            }
-        }
-        checkAttrName(attrNames, { nsIdent, nameIdent });
-        completeNode(syntax_kind_1.SyntaxKind.AttributeKeyNode);
-    }
-    function parseClosingTag(openTagName, skipNameMatching) {
-        if (eat(syntax_kind_1.SyntaxKind.CloseNodeStart)) {
-            if (at(syntax_kind_1.SyntaxKind.Identifier)) {
-                const closeTagName = parseClosingTagName();
-                if (!skipNameMatching) {
-                    const namesMismatch = openTagName !== null &&
-                        !(0, utils_1.tagNameNodesWithoutErrorsMatch)(openTagName, closeTagName, getText);
-                    if (namesMismatch) {
-                        const msg = diagnostics_1.DIAGS.tagNameMismatch(getText(openTagName), getText(closeTagName));
-                        errorAt(msg, closeTagName.pos, closeTagName.end);
-                    }
-                }
-            }
-            else {
-                const errNode = errNodeUntil(RECOVER_CLOSE_TAG);
-                if (errNode) {
-                    errorAt(diagnostics_1.DIAGS.expTagNameAfterCloseStart, errNode.pos, errNode.end);
-                }
-                else {
-                    error(diagnostics_1.DIAGS.expTagNameAfterCloseStart);
-                }
-            }
-            if (!eat(syntax_kind_1.SyntaxKind.NodeEnd)) {
-                error(diagnostics_1.DIAGS.expEnd);
-            }
-        }
-        else {
-            if (openTagName) {
-                errorAt(diagnostics_1.DIAGS.expCloseStartWithName(getText(openTagName)), openTagName.pos, openTagName.end);
-            }
-            else {
-                error(diagnostics_1.DIAGS.expCloseStart);
-            }
-        }
-    }
-    function parseClosingTagName() {
-        startNode();
-        const identNode = bump(syntax_kind_1.SyntaxKind.Identifier);
-        if (eat(syntax_kind_1.SyntaxKind.Colon) && !eat(syntax_kind_1.SyntaxKind.Identifier)) {
-            const nameNodeWithColon = completeNode(syntax_kind_1.SyntaxKind.TagNameNode);
-            errorAt(diagnostics_1.DIAGS.expTagNameAfterNamespace(getText(identNode)), nameNodeWithColon.pos, nameNodeWithColon.end);
-            errNodeUntil(RECOVER_OPEN_TAG);
-            return nameNodeWithColon;
-        }
-        else {
-            return completeNode(syntax_kind_1.SyntaxKind.TagNameNode);
-        }
-    }
-    /** emits errors when the attribute name is incorrect. Otherwise adds the attribute name to the list of valid names*/
-    function checkAttrName(attrNames, { nameIdent, nsIdent }) {
-        const attrName = getText(nameIdent);
-        const attrNs = nsIdent && getText(nsIdent);
-        const attrKeyMatches = ({ ns, name }) => name === attrName && ns === attrNs;
-        const isDuplicate = attrNames.findIndex(attrKeyMatches) !== -1;
-        const nameStartsWithUppercase = "A" <= attrName[0] && attrName[0] <= "Z";
-        const faultyName = isDuplicate || nameStartsWithUppercase;
-        //TODO: account for the namespace as well
-        if (isDuplicate) {
-            errorAt(diagnostics_1.DIAGS.duplAttr(attrName), nameIdent.pos, nameIdent.end);
-        }
-        if (!nsIdent && nameStartsWithUppercase) {
-            errorAt(diagnostics_1.DIAGS.uppercaseAttr(attrName), nameIdent.pos, nameIdent.end);
-        }
-        if (!faultyName) {
-            attrNames.push({ name: attrName, ns: attrNs });
-        }
-    }
-    function getContextWithSurroundingLines(pos, end, surroundingContextLines) {
-        let newlinesFound;
-        let cursor;
-        let contextPos;
-        cursor = pos;
-        newlinesFound = 0;
-        while (cursor >= 0) {
-            if (text[cursor] === "\n") {
-                newlinesFound++;
-                if (newlinesFound > surroundingContextLines) {
-                    break;
-                }
-            }
-            cursor--;
-        }
-        contextPos = cursor + 1;
-        let contextEnd;
-        cursor = end;
-        newlinesFound = 0;
-        while (cursor < text.length) {
-            if (text[cursor] === "\n") {
-                newlinesFound++;
-                if (newlinesFound > surroundingContextLines) {
-                    break;
-                }
-                cursor++;
-            }
-            else if (text[cursor] === "\r" && text[cursor + 1] === "\n") {
-                newlinesFound++;
-                if (newlinesFound > surroundingContextLines) {
-                    break;
-                }
-                cursor += 2;
-            }
-            else {
-                cursor++;
-            }
-        }
-        contextEnd = cursor;
-        return { contextPos, contextEnd };
-    }
-    function error({ code, message, category }) {
-        const { pos, end } = peek();
-        const { contextPos, contextEnd } = getContextWithSurroundingLines(pos, end, 1);
-        errors.push({
-            category,
-            code,
-            message,
-            pos,
-            end,
-            contextPos,
-            contextEnd,
-        });
-    }
-    function errorAt({ code, message, category }, pos, end) {
-        const { contextPos, contextEnd } = getContextWithSurroundingLines(pos, end, 1);
-        errors.push({
-            category,
-            code,
-            message,
-            pos,
-            end,
-            contextPos,
-            contextEnd,
-        });
-    }
-    /**
-     *
-     * @param tokens that won't be consumed
-     * @returns the error node with the consumed tokens, or null if there were no tokens consumed
-     */
-    function errNodeUntil(tokens) {
-        startNode();
-        advance(tokens);
-        if (node.children.length === 0) {
-            abandonNode();
-            return null;
-        }
-        else {
-            return completeNode(syntax_kind_1.SyntaxKind.ErrorNode);
-        }
-    }
-    function advance(to) {
-        for (let token = peek(); token.kind !== syntax_kind_1.SyntaxKind.EndOfFileToken && !to.includes(token.kind); bumpAny(), token = peek()) { }
-    }
-    function eat(kind) {
-        const kindMatched = at(kind);
-        if (kindMatched) {
-            bumpAny();
-        }
-        return kindMatched;
-    }
-    function at(kindToCheck) {
-        return peek().kind === kindToCheck;
-    }
-    function peek(inContent = false) {
-        if (peekedToken !== undefined) {
-            return peekedToken;
-        }
-        peekedToken = collectToken(inContent);
-        return peekedToken;
-    }
-    function peekInContent() {
-        var _a;
-        const token = peek(true);
-        if (token.kind === syntax_kind_1.SyntaxKind.EndOfFileToken ||
-            token.kind === syntax_kind_1.SyntaxKind.OpenNodeStart ||
-            token.kind === syntax_kind_1.SyntaxKind.Script ||
-            token.kind === syntax_kind_1.SyntaxKind.CData ||
-            token.kind === syntax_kind_1.SyntaxKind.CloseNodeStart) {
-            return token;
-        }
-        const trivia = token.triviaBefore;
-        const triviaLength = (_a = trivia === null || trivia === void 0 ? void 0 : trivia.length) !== null && _a !== void 0 ? _a : 0;
-        let i = 0;
-        let leadingComments = [];
-        let firstNonCommentTriviaIdx = -1;
-        for (; i < triviaLength; ++i) {
-            if (trivia[i].kind === syntax_kind_1.SyntaxKind.CommentTrivia) {
-                leadingComments.push(trivia[i]);
-            }
-            else {
-                firstNonCommentTriviaIdx = i;
-                break;
-            }
-        }
-        let secondCommentGroupStartIdx = -1;
-        for (; i < triviaLength; ++i) {
-            if (trivia[i].kind === syntax_kind_1.SyntaxKind.CommentTrivia) {
-                secondCommentGroupStartIdx = i;
-                break;
-            }
-        }
-        let parseAsStringLiteral = false;
-        if (token.kind === syntax_kind_1.SyntaxKind.StringLiteral) {
-            const beforeLookahead = token.end;
-            const nextToken = collectToken(true);
-            parseAsStringLiteral =
-                nextToken.kind === syntax_kind_1.SyntaxKind.CData ||
-                    nextToken.kind === syntax_kind_1.SyntaxKind.CloseNodeStart ||
-                    nextToken.kind === syntax_kind_1.SyntaxKind.Script ||
-                    nextToken.kind === syntax_kind_1.SyntaxKind.OpenNodeStart;
-            scanner.resetTokenState(beforeLookahead);
-        }
-        let pos;
-        if (parseAsStringLiteral) {
-            pos = token.pos;
-        }
-        else if (leadingComments.length > 0) {
-            pos = leadingComments[leadingComments.length - 1].end;
-        }
-        else if (firstNonCommentTriviaIdx !== -1) {
-            pos = trivia[firstNonCommentTriviaIdx].pos;
-        }
-        else {
-            pos = token.start;
-        }
-        let start = pos;
-        let triviaBefore = undefined;
-        if (leadingComments.length > 0) {
-            triviaBefore = leadingComments;
-            start = leadingComments[0].pos;
-        }
-        let kind = syntax_kind_1.SyntaxKind.TextNode;
-        let end = -1;
-        if (secondCommentGroupStartIdx !== -1) {
-            end = trivia[secondCommentGroupStartIdx].pos;
-            scanner.resetTokenState(end);
-        }
-        else if (parseAsStringLiteral) {
-            kind = syntax_kind_1.SyntaxKind.StringLiteral;
-            end = token.end;
-        }
-        else {
-            while (true) {
-                const nextChar = scanner.peekChar();
-                if (nextChar === null || nextChar === CharacterCodes_1.CharacterCodes.lessThan) {
-                    break;
-                }
-                scanner.scanChar();
-            }
-            end = scanner.getTokenEnd();
-        }
-        peekedToken = new syntax_node_1.Node(kind, pos, end, triviaBefore);
-        return peekedToken;
-    }
-    /** Same as bumpAny, but with an assertion of the token that was bumped over.
-     * Makes the code more redundant, but also more defensive*/
-    function bump(kind) {
-        const token = bumpAny();
-        if (token.kind !== kind) {
-            throw new Error(`expected ${(0, syntax_kind_1.getSyntaxKindStrRepr)(kind)}, bumped a ${(0, syntax_kind_1.getSyntaxKindStrRepr)(token.kind)}`);
-        }
-        return token;
-    }
-    function bumpAny() {
-        if (peekedToken) {
-            node.children.push(peekedToken);
-            const bumpedToken = peekedToken;
-            peekedToken = undefined;
-            return bumpedToken;
-        }
-        const token = collectToken(false);
-        node.children.push(token);
-        return token;
-    }
-    /** start a new node. Any new tokens or nodes will be put into it's children list from that point. Each call to this should be paired with a [completeNode] */
-    function startNode() {
-        parents.push(node);
-        node = {
-            children: [],
-        };
-    }
-    function completeNode(type) {
-        const completedNode = createNode(type, node.children);
-        const parentNode = parents[parents.length - 1];
-        parentNode.children.push(completedNode);
-        node = parentNode;
-        parents.pop();
-        return completedNode;
-    }
-    function collectToken(inContent) {
-        let kind;
-        let triviaCollected = [];
-        let start = null;
-        while (true) {
-            kind = scanner.scan();
-            if (start === null) {
-                start = scanner.getTokenStart();
-            }
-            //handle error from scanner
-            if (errFromScanner !== undefined) {
-                let err;
-                if (errFromScanner.message.code === diagnostics_1.ErrCodes.invalidChar) {
-                    err = diagnostics_1.DIAGS.invalidChar(scanner.getTokenText());
-                }
-                else {
-                    err = errFromScanner.message;
-                }
-                const pos = scanner.getTokenStart();
-                const triviaBefore = triviaCollected.length > 0 ? triviaCollected : undefined;
-                triviaCollected = [];
-                if (inContent && err.code === diagnostics_1.ErrCodes.invalidChar) {
-                    errFromScanner = undefined;
-                    return new syntax_node_1.Node(kind, pos, scanner.getTokenEnd(), triviaBefore);
-                }
-                const badPrefixEnd = pos + errFromScanner.prefixLength;
-                const token = new syntax_node_1.Node(kind, pos, badPrefixEnd, triviaBefore);
-                scanner.resetTokenState(badPrefixEnd);
-                startNode();
-                node.children.push(token);
-                const { contextPos, contextEnd } = getContextWithSurroundingLines(pos, badPrefixEnd, 0);
-                errors.push({
-                    category: err.category,
-                    code: err.code,
-                    message: err.message,
-                    pos,
-                    end: badPrefixEnd,
-                    contextPos,
-                    contextEnd,
-                });
-                completeNode(syntax_kind_1.SyntaxKind.ErrorNode);
-                errFromScanner = undefined;
-                return collectToken(inContent);
-            }
-            switch (kind) {
-                case syntax_kind_1.SyntaxKind.CommentTrivia:
-                case syntax_kind_1.SyntaxKind.NewLineTrivia:
-                case syntax_kind_1.SyntaxKind.WhitespaceTrivia:
-                    triviaCollected.push(new syntax_node_1.Node(kind, scanner.getTokenStart(), scanner.getTokenEnd()));
-                    break;
-                default:
-                    return new syntax_node_1.Node(kind, scanner.getTokenStart(), scanner.getTokenEnd(), triviaCollected.length > 0 ? triviaCollected : undefined);
-            }
-        }
-    }
-    function abandonNode() {
-        const parentNode = parents[parents.length - 1];
-        parentNode.children.push(...node.children);
-        node = parentNode;
-        parents.pop();
-    }
-}
-function createNode(kind, children) {
-    const firstChild = children[0];
-    const lastChild = children[children.length - 1];
-    return new syntax_node_1.Node(kind, firstChild.pos, lastChild.end, undefined, children);
-}