xmlui 0.11.4 → 0.11.7

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

@@ -1,415 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createScanner = createScanner;
-exports.isIdentifierStart = isIdentifierStart;
-const CharacterCodes_1 = require("./CharacterCodes");
-const diagnostics_1 = require("./diagnostics");
-const syntax_kind_1 = require("./syntax-kind");
-function createScanner(skipTrivia, textInitial, onError, start, length) {
-    let text = textInitial !== null && textInitial !== void 0 ? textInitial : "";
-    // Current position (end position of text of current token)
-    let pos;
-    // End of text
-    let end;
-    // Start position of whitespace before current token
-    let fullStartPos;
-    // Start position of text of current token
-    let tokenStart;
-    let token;
-    let tokenValue;
-    setText(text, start, length);
-    // Create the scanner instance
-    return {
-        getStartPos: () => fullStartPos,
-        getTokenEnd: () => pos,
-        getToken: () => token,
-        getTokenStart: () => tokenStart,
-        getTokenText: () => text.substring(tokenStart, pos),
-        getTokenValue: () => tokenValue,
-        isIdentifier: () => token === syntax_kind_1.SyntaxKind.Identifier,
-        peekChar,
-        scanChar,
-        scan,
-        scanTrivia,
-        scanText,
-        getText,
-        setText,
-        setOnError,
-        resetTokenState,
-        back,
-    };
-    function peekChar(ahead) {
-        if (pos + (ahead !== null && ahead !== void 0 ? ahead : 0) >= end) {
-            return null;
-        }
-        const ch = codePointUnchecked(pos + (ahead !== null && ahead !== void 0 ? ahead : 0));
-        return isNaN(ch) ? null : ch;
-    }
-    function scanChar() {
-        if (pos >= end) {
-            return null;
-        }
-        const ch = codePointUnchecked(pos);
-        pos += charSize(ch);
-        return ch;
-    }
-    function scan() {
-        fullStartPos = pos;
-        while (true) {
-            tokenStart = pos;
-            if (pos >= end) {
-                return (token = syntax_kind_1.SyntaxKind.EndOfFileToken);
-            }
-            const ch = codePointUnchecked(pos);
-            switch (ch) {
-                // --- Collect line break
-                case CharacterCodes_1.CharacterCodes.lineFeed:
-                case CharacterCodes_1.CharacterCodes.carriageReturn:
-                    if (skipTrivia) {
-                        pos++;
-                        continue;
-                    }
-                    else {
-                        if (ch === CharacterCodes_1.CharacterCodes.carriageReturn &&
-                            pos + 1 < end &&
-                            charCodeUnchecked(pos + 1) === CharacterCodes_1.CharacterCodes.lineFeed) {
-                            // consume both CR and LF
-                            pos += 2;
-                        }
-                        else {
-                            pos++;
-                        }
-                        return (token = syntax_kind_1.SyntaxKind.NewLineTrivia);
-                    }
-                // --- Collect whitespace
-                case CharacterCodes_1.CharacterCodes.tab:
-                case CharacterCodes_1.CharacterCodes.verticalTab:
-                case CharacterCodes_1.CharacterCodes.formFeed:
-                case CharacterCodes_1.CharacterCodes.space:
-                case CharacterCodes_1.CharacterCodes.nonBreakingSpace:
-                case CharacterCodes_1.CharacterCodes.ogham:
-                case CharacterCodes_1.CharacterCodes.enQuad:
-                case CharacterCodes_1.CharacterCodes.emQuad:
-                case CharacterCodes_1.CharacterCodes.enSpace:
-                case CharacterCodes_1.CharacterCodes.emSpace:
-                case CharacterCodes_1.CharacterCodes.threePerEmSpace:
-                case CharacterCodes_1.CharacterCodes.fourPerEmSpace:
-                case CharacterCodes_1.CharacterCodes.sixPerEmSpace:
-                case CharacterCodes_1.CharacterCodes.figureSpace:
-                case CharacterCodes_1.CharacterCodes.punctuationSpace:
-                case CharacterCodes_1.CharacterCodes.thinSpace:
-                case CharacterCodes_1.CharacterCodes.hairSpace:
-                case CharacterCodes_1.CharacterCodes.zeroWidthSpace:
-                case CharacterCodes_1.CharacterCodes.narrowNoBreakSpace:
-                case CharacterCodes_1.CharacterCodes.mathematicalSpace:
-                case CharacterCodes_1.CharacterCodes.ideographicSpace:
-                case CharacterCodes_1.CharacterCodes.byteOrderMark:
-                    if (skipTrivia) {
-                        pos++;
-                        continue;
-                    }
-                    else {
-                        while (pos < end && isWhiteSpaceSingleLine(charCodeUnchecked(pos))) {
-                            pos++;
-                        }
-                        return (token = syntax_kind_1.SyntaxKind.WhitespaceTrivia);
-                    }
-                // --- Collect string literal
-                case CharacterCodes_1.CharacterCodes.doubleQuote:
-                case CharacterCodes_1.CharacterCodes.singleQuote:
-                case CharacterCodes_1.CharacterCodes.backtick:
-                    tokenValue = scanString();
-                    return (token = syntax_kind_1.SyntaxKind.StringLiteral);
-                // --- Collext XML entities
-                case CharacterCodes_1.CharacterCodes.ampersand:
-                    if (charCodeUnchecked(pos + 1) === CharacterCodes_1.CharacterCodes.a &&
-                        charCodeUnchecked(pos + 2) === CharacterCodes_1.CharacterCodes.m &&
-                        charCodeUnchecked(pos + 3) === CharacterCodes_1.CharacterCodes.p &&
-                        charCodeUnchecked(pos + 4) === CharacterCodes_1.CharacterCodes.semicolon) {
-                        pos += 5;
-                        return (token = syntax_kind_1.SyntaxKind.AmpersandEntity);
-                    }
-                    else if (charCodeUnchecked(pos + 1) === CharacterCodes_1.CharacterCodes.l &&
-                        charCodeUnchecked(pos + 2) === CharacterCodes_1.CharacterCodes.t &&
-                        charCodeUnchecked(pos + 3) === CharacterCodes_1.CharacterCodes.semicolon) {
-                        pos += 4;
-                        return (token = syntax_kind_1.SyntaxKind.LessThanEntity);
-                    }
-                    else if (charCodeUnchecked(pos + 1) === CharacterCodes_1.CharacterCodes.g &&
-                        charCodeUnchecked(pos + 2) === CharacterCodes_1.CharacterCodes.t &&
-                        charCodeUnchecked(pos + 3) === CharacterCodes_1.CharacterCodes.semicolon) {
-                        pos += 4;
-                        return (token = syntax_kind_1.SyntaxKind.GreaterThanEntity);
-                    }
-                    else if (charCodeUnchecked(pos + 1) === CharacterCodes_1.CharacterCodes.q &&
-                        charCodeUnchecked(pos + 2) === CharacterCodes_1.CharacterCodes.u &&
-                        charCodeUnchecked(pos + 3) === CharacterCodes_1.CharacterCodes.o &&
-                        charCodeUnchecked(pos + 4) === CharacterCodes_1.CharacterCodes.t &&
-                        charCodeUnchecked(pos + 5) === CharacterCodes_1.CharacterCodes.semicolon) {
-                        pos += 6;
-                        return (token = syntax_kind_1.SyntaxKind.DoubleQuoteEntity);
-                    }
-                    else if (charCodeUnchecked(pos + 1) === CharacterCodes_1.CharacterCodes.a &&
-                        charCodeUnchecked(pos + 2) === CharacterCodes_1.CharacterCodes.p &&
-                        charCodeUnchecked(pos + 3) === CharacterCodes_1.CharacterCodes.o &&
-                        charCodeUnchecked(pos + 4) === CharacterCodes_1.CharacterCodes.s &&
-                        charCodeUnchecked(pos + 5) === CharacterCodes_1.CharacterCodes.semicolon) {
-                        pos += 6;
-                        return (token = syntax_kind_1.SyntaxKind.SingleQuoteEntity);
-                    }
-                    pos++;
-                    error(diagnostics_1.Diag_Invalid_Character, 1);
-                    return (token = syntax_kind_1.SyntaxKind.Unknown);
-                // --- Collect equal token
-                case CharacterCodes_1.CharacterCodes.equals:
-                    pos++;
-                    return (token = syntax_kind_1.SyntaxKind.Equal);
-                // --- Collect colon token
-                case CharacterCodes_1.CharacterCodes.colon:
-                    pos++;
-                    return (token = syntax_kind_1.SyntaxKind.Colon);
-                // --- Collect tokens starting with '<'
-                case CharacterCodes_1.CharacterCodes.lessThan:
-                    if (charCodeUnchecked(pos + 1) === CharacterCodes_1.CharacterCodes.slash) {
-                        // --- "</"
-                        pos += 2;
-                        return (token = syntax_kind_1.SyntaxKind.CloseNodeStart);
-                    }
-                    else if (
-                    // --- "<!-- -->", XMLUI comment
-                    charCodeUnchecked(pos + 1) === CharacterCodes_1.CharacterCodes.exclamation &&
-                        charCodeUnchecked(pos + 2) === CharacterCodes_1.CharacterCodes.minus &&
-                        charCodeUnchecked(pos + 3) === CharacterCodes_1.CharacterCodes.minus) {
-                        pos += 4;
-                        while (pos < end) {
-                            if (charCodeUnchecked(pos) === CharacterCodes_1.CharacterCodes.minus &&
-                                charCodeUnchecked(pos + 1) === CharacterCodes_1.CharacterCodes.minus &&
-                                charCodeUnchecked(pos + 2) === CharacterCodes_1.CharacterCodes.greaterThan) {
-                                pos += 3;
-                                return (token = syntax_kind_1.SyntaxKind.CommentTrivia);
-                            }
-                            pos += charSize(charCodeUnchecked(pos));
-                        }
-                        error(diagnostics_1.Diag_Unterminated_Comment, 4);
-                        return (token = syntax_kind_1.SyntaxKind.Unknown);
-                    }
-                    else if (
-                    // --- <![CDATA[ section
-                    charCodeUnchecked(pos + 1) === CharacterCodes_1.CharacterCodes.exclamation &&
-                        charCodeUnchecked(pos + 2) === CharacterCodes_1.CharacterCodes.openBracket &&
-                        charCodeUnchecked(pos + 3) === CharacterCodes_1.CharacterCodes.C &&
-                        charCodeUnchecked(pos + 4) === CharacterCodes_1.CharacterCodes.D &&
-                        charCodeUnchecked(pos + 5) === CharacterCodes_1.CharacterCodes.A &&
-                        charCodeUnchecked(pos + 6) === CharacterCodes_1.CharacterCodes.T &&
-                        charCodeUnchecked(pos + 7) === CharacterCodes_1.CharacterCodes.A &&
-                        charCodeUnchecked(pos + 8) === CharacterCodes_1.CharacterCodes.openBracket) {
-                        pos += 9;
-                        while (pos < end) {
-                            if (charCodeUnchecked(pos) === CharacterCodes_1.CharacterCodes.closeBracket &&
-                                charCodeUnchecked(pos + 1) === CharacterCodes_1.CharacterCodes.closeBracket &&
-                                charCodeUnchecked(pos + 2) === CharacterCodes_1.CharacterCodes.greaterThan) {
-                                pos += 3;
-                                return (token = syntax_kind_1.SyntaxKind.CData);
-                            }
-                            pos += charSize(charCodeUnchecked(pos));
-                        }
-                        error(diagnostics_1.Diag_Unterminated_CData, 9);
-                        return (token = syntax_kind_1.SyntaxKind.CData);
-                    }
-                    else if (
-                    // --- <script>
-                    charCodeUnchecked(pos + 1) === CharacterCodes_1.CharacterCodes.s &&
-                        charCodeUnchecked(pos + 2) === CharacterCodes_1.CharacterCodes.c &&
-                        charCodeUnchecked(pos + 3) === CharacterCodes_1.CharacterCodes.r &&
-                        charCodeUnchecked(pos + 4) === CharacterCodes_1.CharacterCodes.i &&
-                        charCodeUnchecked(pos + 5) === CharacterCodes_1.CharacterCodes.p &&
-                        charCodeUnchecked(pos + 6) === CharacterCodes_1.CharacterCodes.t &&
-                        charCodeUnchecked(pos + 7) === CharacterCodes_1.CharacterCodes.greaterThan) {
-                        pos += 8;
-                        while (pos < end) {
-                            if (charCodeUnchecked(pos) === CharacterCodes_1.CharacterCodes.lessThan &&
-                                charCodeUnchecked(pos + 1) === CharacterCodes_1.CharacterCodes.slash &&
-                                charCodeUnchecked(pos + 2) === CharacterCodes_1.CharacterCodes.s &&
-                                charCodeUnchecked(pos + 3) === CharacterCodes_1.CharacterCodes.c &&
-                                charCodeUnchecked(pos + 4) === CharacterCodes_1.CharacterCodes.r &&
-                                charCodeUnchecked(pos + 5) === CharacterCodes_1.CharacterCodes.i &&
-                                charCodeUnchecked(pos + 6) === CharacterCodes_1.CharacterCodes.p &&
-                                charCodeUnchecked(pos + 7) === CharacterCodes_1.CharacterCodes.t &&
-                                charCodeUnchecked(pos + 8) === CharacterCodes_1.CharacterCodes.greaterThan) {
-                                pos += 9;
-                                return (token = syntax_kind_1.SyntaxKind.Script);
-                            }
-                            pos += charSize(charCodeUnchecked(pos));
-                        }
-                        error(diagnostics_1.Diag_Unterminated_Script, 9);
-                        return (token = syntax_kind_1.SyntaxKind.Script);
-                    }
-                    pos++;
-                    return (token = syntax_kind_1.SyntaxKind.OpenNodeStart);
-                case CharacterCodes_1.CharacterCodes.slash:
-                    if (charCodeUnchecked(pos + 1) === CharacterCodes_1.CharacterCodes.greaterThan) {
-                        pos += 2;
-                        return (token = syntax_kind_1.SyntaxKind.NodeClose);
-                    }
-                    pos++;
-                    error(diagnostics_1.Diag_Invalid_Character, 1);
-                    return (token = syntax_kind_1.SyntaxKind.Unknown);
-                // --- Collect node closing token
-                case CharacterCodes_1.CharacterCodes.greaterThan:
-                    pos++;
-                    return (token = syntax_kind_1.SyntaxKind.NodeEnd);
-                default:
-                    const identifierKind = scanIdentifier(ch);
-                    if (identifierKind) {
-                        return (token = identifierKind);
-                    }
-                    else if (isWhiteSpaceSingleLine(ch)) {
-                        pos += charSize(ch);
-                        continue;
-                    }
-                    else if (isLineBreak(ch)) {
-                        pos += charSize(ch);
-                        continue;
-                    }
-                    const size = charSize(ch);
-                    pos += size;
-                    error(diagnostics_1.Diag_Invalid_Character, size);
-                    return (token = syntax_kind_1.SyntaxKind.Unknown);
-            }
-        }
-    }
-    function scanTrivia() {
-        const currentPos = pos;
-        const token = scan();
-        if ((0, syntax_kind_1.isTrivia)(token)) {
-            return token;
-        }
-        resetTokenState(currentPos);
-        return null;
-    }
-    function scanText() {
-        return syntax_kind_1.SyntaxKind.Unknown;
-    }
-    function getText() {
-        return text;
-    }
-    /**
-     * Returns the char code for the character at the given position within `text`. This
-     * should only be used when pos is guaranteed to be within the bounds of `text` as this
-     * function does not perform bounds checks.
-     */
-    function charCodeUnchecked(pos) {
-        return text.charCodeAt(pos);
-    }
-    function codePointUnchecked(pos) {
-        return codePointAt(text, pos);
-    }
-    function codePointAt(s, i) {
-        var _a;
-        return (_a = s.codePointAt(i)) !== null && _a !== void 0 ? _a : 0;
-    }
-    function setText(newText, start, length) {
-        text = newText || "";
-        end = length === undefined ? text.length : start + length;
-        resetTokenState(start || 0);
-    }
-    function setOnError(errorCallback) {
-        onError = errorCallback;
-    }
-    function resetTokenState(position) {
-        pos = position;
-        fullStartPos = position;
-        tokenStart = position;
-        token = syntax_kind_1.SyntaxKind.Unknown;
-        tokenValue = undefined;
-    }
-    function back() {
-        resetTokenState(fullStartPos);
-    }
-    function scanIdentifier(startCharacter) {
-        let ch = startCharacter;
-        if (isIdentifierStart(ch)) {
-            pos += charSize(ch);
-            while (pos < end && isIdentifierPart((ch = codePointUnchecked(pos)))) {
-                pos += charSize(ch);
-            }
-            tokenValue = text.substring(tokenStart, pos);
-            return getIdentifierToken();
-        }
-    }
-    function getIdentifierToken() {
-        return (token = syntax_kind_1.SyntaxKind.Identifier);
-    }
-    function scanString() {
-        const quote = charCodeUnchecked(pos);
-        pos++;
-        let result = "";
-        let start = pos;
-        while (true) {
-            if (pos >= end) {
-                result += text.substring(start, pos);
-                error(diagnostics_1.Diag_Unterminated_String_Literal, 1);
-                break;
-            }
-            const ch = charCodeUnchecked(pos);
-            if (ch === quote) {
-                result += text.substring(start, pos);
-                pos++;
-                break;
-            }
-            pos++;
-        }
-        return result;
-    }
-    function error(message, troublesomePrefixLength = 0) {
-        if (onError) {
-            onError(message, troublesomePrefixLength);
-        }
-    }
-}
-function charSize(ch) {
-    if (ch >= 0x10000) {
-        return 2;
-    }
-    if (ch === CharacterCodes_1.CharacterCodes.EOF) {
-        return 0;
-    }
-    return 1;
-}
-function isASCIILetter(ch) {
-    return (ch >= CharacterCodes_1.CharacterCodes.A && ch <= CharacterCodes_1.CharacterCodes.Z) || (ch >= CharacterCodes_1.CharacterCodes.a && ch <= CharacterCodes_1.CharacterCodes.z);
-}
-function isWordCharacter(ch) {
-    return isASCIILetter(ch) || isDigit(ch) || ch === CharacterCodes_1.CharacterCodes._;
-}
-function isDigit(ch) {
-    return ch >= CharacterCodes_1.CharacterCodes._0 && ch <= CharacterCodes_1.CharacterCodes._9;
-}
-function isIdentifierStart(ch) {
-    return isASCIILetter(ch) || ch === CharacterCodes_1.CharacterCodes.$ || ch === CharacterCodes_1.CharacterCodes._;
-}
-function isIdentifierPart(ch) {
-    return isWordCharacter(ch) || ch === CharacterCodes_1.CharacterCodes.$ || ch === CharacterCodes_1.CharacterCodes.minus || ch === CharacterCodes_1.CharacterCodes.dot;
-}
-function isWhiteSpaceSingleLine(ch) {
-    // Note: nextLine is in the Zs space, and should be considered to be a whitespace.
-    // It is explicitly not a line-break as it isn't in the exact set specified by EcmaScript.
-    return (ch === CharacterCodes_1.CharacterCodes.space ||
-        ch === CharacterCodes_1.CharacterCodes.tab ||
-        ch === CharacterCodes_1.CharacterCodes.verticalTab ||
-        ch === CharacterCodes_1.CharacterCodes.formFeed ||
-        ch === CharacterCodes_1.CharacterCodes.nonBreakingSpace ||
-        ch === CharacterCodes_1.CharacterCodes.nextLine ||
-        ch === CharacterCodes_1.CharacterCodes.ogham ||
-        (ch >= CharacterCodes_1.CharacterCodes.enQuad && ch <= CharacterCodes_1.CharacterCodes.zeroWidthSpace) ||
-        ch === CharacterCodes_1.CharacterCodes.narrowNoBreakSpace ||
-        ch === CharacterCodes_1.CharacterCodes.mathematicalSpace ||
-        ch === CharacterCodes_1.CharacterCodes.ideographicSpace ||
-        ch === CharacterCodes_1.CharacterCodes.byteOrderMark);
-}
-function isLineBreak(ch) {
-    return (ch === CharacterCodes_1.CharacterCodes.lineFeed ||
-        ch === CharacterCodes_1.CharacterCodes.carriageReturn ||
-        ch === CharacterCodes_1.CharacterCodes.lineSeparator ||
-        ch === CharacterCodes_1.CharacterCodes.paragraphSeparator);
-}

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

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyntaxKind = void 0;
-exports.isTrivia = isTrivia;
-exports.isInnerNode = isInnerNode;
-exports.getSyntaxKindStrRepr = getSyntaxKindStrRepr;
-/** tokens and nodes combined. Order is significant since the functions below use the numeric values of this enum to check for a range of possible values*/
-var SyntaxKind;
-(function (SyntaxKind) {
-    SyntaxKind[SyntaxKind["Unknown"] = 0] = "Unknown";
-    SyntaxKind[SyntaxKind["EndOfFileToken"] = 1] = "EndOfFileToken";
-    // Trivia (skipped tokens)
-    SyntaxKind[SyntaxKind["CommentTrivia"] = 2] = "CommentTrivia";
-    SyntaxKind[SyntaxKind["NewLineTrivia"] = 3] = "NewLineTrivia";
-    SyntaxKind[SyntaxKind["WhitespaceTrivia"] = 4] = "WhitespaceTrivia";
-    // Effective tokens
-    SyntaxKind[SyntaxKind["Identifier"] = 5] = "Identifier";
-    /** < */
-    SyntaxKind[SyntaxKind["OpenNodeStart"] = 6] = "OpenNodeStart";
-    /** </ */
-    SyntaxKind[SyntaxKind["CloseNodeStart"] = 7] = "CloseNodeStart";
-    /** > */
-    SyntaxKind[SyntaxKind["NodeEnd"] = 8] = "NodeEnd";
-    /** /> */
-    SyntaxKind[SyntaxKind["NodeClose"] = 9] = "NodeClose";
-    /** : */
-    SyntaxKind[SyntaxKind["Colon"] = 10] = "Colon";
-    /** = */
-    SyntaxKind[SyntaxKind["Equal"] = 11] = "Equal";
-    /** string literal */
-    SyntaxKind[SyntaxKind["StringLiteral"] = 12] = "StringLiteral";
-    /** <![CDATA[ ... ]]> */
-    SyntaxKind[SyntaxKind["CData"] = 13] = "CData";
-    /** <script>...</script> */
-    SyntaxKind[SyntaxKind["Script"] = 14] = "Script";
-    // A token created by the parser which contains arbitrary text, but not the '<' character
-    SyntaxKind[SyntaxKind["TextNode"] = 15] = "TextNode";
-    // XMLUI entities
-    SyntaxKind[SyntaxKind["AmpersandEntity"] = 16] = "AmpersandEntity";
-    SyntaxKind[SyntaxKind["LessThanEntity"] = 17] = "LessThanEntity";
-    SyntaxKind[SyntaxKind["GreaterThanEntity"] = 18] = "GreaterThanEntity";
-    SyntaxKind[SyntaxKind["SingleQuoteEntity"] = 19] = "SingleQuoteEntity";
-    SyntaxKind[SyntaxKind["DoubleQuoteEntity"] = 20] = "DoubleQuoteEntity";
-    // Syntax node types
-    SyntaxKind[SyntaxKind["ElementNode"] = 21] = "ElementNode";
-    SyntaxKind[SyntaxKind["AttributeNode"] = 22] = "AttributeNode";
-    SyntaxKind[SyntaxKind["AttributeKeyNode"] = 23] = "AttributeKeyNode";
-    SyntaxKind[SyntaxKind["ContentListNode"] = 24] = "ContentListNode";
-    SyntaxKind[SyntaxKind["AttributeListNode"] = 25] = "AttributeListNode";
-    SyntaxKind[SyntaxKind["TagNameNode"] = 26] = "TagNameNode";
-    // should be the last syntax node type
-    SyntaxKind[SyntaxKind["ErrorNode"] = 27] = "ErrorNode";
-})(SyntaxKind || (exports.SyntaxKind = SyntaxKind = {}));
-function isTrivia(token) {
-    return token >= SyntaxKind.CommentTrivia && token <= SyntaxKind.WhitespaceTrivia;
-}
-function isInnerNode(token) {
-    return token >= SyntaxKind.ElementNode && token <= SyntaxKind.ErrorNode;
-}
-function getSyntaxKindStrRepr(kind) {
-    switch (kind) {
-        case SyntaxKind.Unknown:
-            return "Unknown";
-        case SyntaxKind.EndOfFileToken:
-            return "EndOfFileToken";
-        case SyntaxKind.CommentTrivia:
-            return "CommentTrivia";
-        case SyntaxKind.NewLineTrivia:
-            return "NewLineTrivia";
-        case SyntaxKind.WhitespaceTrivia:
-            return "WhitespaceTrivia";
-        case SyntaxKind.Identifier:
-            return "Identifier";
-        case SyntaxKind.OpenNodeStart:
-            return "OpenNodeStart";
-        case SyntaxKind.CloseNodeStart:
-            return "CloseNodeStart";
-        case SyntaxKind.NodeEnd:
-            return "NodeEnd";
-        case SyntaxKind.NodeClose:
-            return "NodeClose";
-        case SyntaxKind.Colon:
-            return "Colon";
-        case SyntaxKind.Equal:
-            return "Equal";
-        case SyntaxKind.StringLiteral:
-            return "StringLiteral";
-        case SyntaxKind.CData:
-            return "CData";
-        case SyntaxKind.Script:
-            return "Script";
-        case SyntaxKind.AmpersandEntity:
-            return "AmpersandEntity";
-        case SyntaxKind.LessThanEntity:
-            return "LessThanEntity";
-        case SyntaxKind.GreaterThanEntity:
-            return "GreaterThanEntity";
-        case SyntaxKind.SingleQuoteEntity:
-            return "SingleQuoteEntity";
-        case SyntaxKind.DoubleQuoteEntity:
-            return "DoubleQuoteEntity";
-        case SyntaxKind.ElementNode:
-            return "ElementNode";
-        case SyntaxKind.AttributeNode:
-            return "AttributeNode";
-        case SyntaxKind.TextNode:
-            return "TextNode";
-        case SyntaxKind.ContentListNode:
-            return "ContentListNode";
-        case SyntaxKind.AttributeListNode:
-            return "AttributeListNode";
-        case SyntaxKind.TagNameNode:
-            return "TagNameNode";
-        case SyntaxKind.ErrorNode:
-            return "ErrorNode";
-        case SyntaxKind.AttributeKeyNode:
-            return "AttributeKeyNode";
-    }
-    return assertUnreachable(kind);
-}
-function assertUnreachable(x) {
-    throw new Error("Didn't expect to get here");
-}

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

@@ -1,83 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TagNameNode = exports.AttributeListNode = exports.ContentListNode = exports.AttributeKeyNode = exports.AttributeNode = exports.ElementNode = exports.Node = void 0;
-const syntax_kind_1 = require("./syntax-kind");
-const utils_1 = require("./utils");
-class Node {
-    constructor(kind, pos, end, triviaBefore, children) {
-        var _a, _b, _c, _d;
-        this.kind = kind;
-        this.pos = pos;
-        this.end = end;
-        this.triviaBefore = triviaBefore;
-        this.children = children;
-        if (triviaBefore) {
-            this.start = (_b = (_a = triviaBefore[0]) === null || _a === void 0 ? void 0 : _a.start) !== null && _b !== void 0 ? _b : pos;
-        }
-        else if (children) {
-            this.start = (_d = (_c = children[0]) === null || _c === void 0 ? void 0 : _c.start) !== null && _d !== void 0 ? _d : pos;
-        }
-        else {
-            this.start = pos;
-        }
-    }
-    isElementNode() {
-        return this.kind === syntax_kind_1.SyntaxKind.ElementNode;
-    }
-    isAttributeNode() {
-        return this.kind === syntax_kind_1.SyntaxKind.AttributeNode;
-    }
-    isTagLike() {
-        return (this.kind === syntax_kind_1.SyntaxKind.ElementNode ||
-            this.kind === syntax_kind_1.SyntaxKind.CData ||
-            this.kind == syntax_kind_1.SyntaxKind.Script);
-    }
-    isAttributeKeyNode() {
-        return this.kind === syntax_kind_1.SyntaxKind.AttributeKeyNode;
-    }
-    isContentListNode() {
-        return this.kind === syntax_kind_1.SyntaxKind.ContentListNode;
-    }
-    isAttributeListNode() {
-        return this.kind === syntax_kind_1.SyntaxKind.AttributeListNode;
-    }
-    isTagNameNode() {
-        return this.kind === syntax_kind_1.SyntaxKind.TagNameNode;
-    }
-    findTokenAtPos(position) {
-        return (0, utils_1.findTokenAtPos)(this, position);
-    }
-    getTriviaNodes() {
-        if (this.pos === this.start) {
-            return null;
-        }
-        else if (this.triviaBefore) {
-            return this.triviaBefore;
-        }
-        else {
-            return this.children[0].getTriviaNodes();
-        }
-    }
-}
-exports.Node = Node;
-class ElementNode extends Node {
-    getAttributeListNode() {
-        return this.children.find((c) => c.isContentListNode());
-    }
-}
-exports.ElementNode = ElementNode;
-class AttributeNode extends Node {
-}
-exports.AttributeNode = AttributeNode;
-class AttributeKeyNode extends Node {
-}
-exports.AttributeKeyNode = AttributeKeyNode;
-class ContentListNode extends Node {
-}
-exports.ContentListNode = ContentListNode;
-class AttributeListNode extends Node {
-}
-exports.AttributeListNode = AttributeListNode;
-class TagNameNode extends Node {
-}
-exports.TagNameNode = TagNameNode;