xmlui 0.4.0

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

@@ -0,0 +1,415 @@
+"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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyntaxKind = void 0;
+exports.isTrivia = isTrivia;
+exports.isInnerNode = isInnerNode;
+exports.getSyntaxKindStrRepr = getSyntaxKindStrRepr;
+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";
+    SyntaxKind[SyntaxKind["StringLiteral"] = 12] = "StringLiteral";
+    SyntaxKind[SyntaxKind["CData"] = 13] = "CData";
+    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["ContentListNode"] = 23] = "ContentListNode";
+    SyntaxKind[SyntaxKind["AttributeListNode"] = 24] = "AttributeListNode";
+    SyntaxKind[SyntaxKind["TagNameNode"] = 25] = "TagNameNode";
+    // should be the last syntax node type
+    SyntaxKind[SyntaxKind["ErrorNode"] = 26] = "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';
+    }
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });