xmlui 0.4.0

package/dist/scripts/src/parsers/ueml/UemlParser.js

@@ -0,0 +1,1439 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UemlParser = void 0;
+const UemlInputStream_1 = require("./UemlInputStream");
+const UemlLexer_1 = require("./UemlLexer");
+const UemlToken_1 = require("./UemlToken");
+const ParserError_1 = require("./ParserError");
+const UemlHelper_1 = require("./UemlHelper");
+const Parser_1 = require("../scripting/Parser");
+const code_behind_collect_1 = require("../scripting/code-behind-collect");
+const BindingTreeEvaluationContext_1 = require("../../components-core/script-runner/BindingTreeEvaluationContext");
+/**
+ * This class parses a binding expression and transforms it into an evaluable expression tree
+ */
+class UemlParser {
+    /**
+     * Initializes the parser with the specified source code
+     * @param source Source code to parse
+     * @param moduleResolver
+     */
+    constructor(source, moduleResolver = () => "") {
+        this.source = source;
+        this.moduleResolver = moduleResolver;
+        // --- Keep track of error messages
+        this._parseErrors = [];
+        this._lexer = new UemlLexer_1.UemlLexer(new UemlInputStream_1.UemlInputStream(source));
+    }
+    /**
+     * The errors raised during the parse phase
+     */
+    get errors() {
+        return this._parseErrors;
+    }
+    /**
+     * Gets the current token
+     */
+    get current() {
+        return this._lexer.peek();
+    }
+    /**
+     * Checks if we're at the end of the expression
+     */
+    get isEof() {
+        return this._lexer.peek().type === UemlToken_1.UemlTokenType.Eof;
+    }
+    /**
+     * Parses a component element
+     *
+     * umlNode
+     *   : umlComment* umlElement umlComment*
+     *   ;
+     *
+     * umlComment:
+     *   : "<!-- {any chars} -->"
+     *   ;
+     */
+    parseComponentElement() {
+        const nodes = [];
+        let hasUmlElement = false;
+        let startToken = this._lexer.peek();
+        while (!this.isEof) {
+            switch (startToken.type) {
+                case UemlToken_1.UemlTokenType.Comment:
+                    const commentToken = this._lexer.get();
+                    nodes.push(this.createNode("Comment", {
+                        text: commentToken.text,
+                    }, startToken));
+                    break;
+                case UemlToken_1.UemlTokenType.OpenNodeStart:
+                    if (hasUmlElement) {
+                        this.reportError("U002", startToken);
+                        return null;
+                    }
+                    const element = this.parseElement();
+                    if (!element) {
+                        return null;
+                    }
+                    nodes.push(element);
+                    hasUmlElement = true;
+                    break;
+                default:
+                    this.reportError("U001", startToken, startToken.text);
+                    return null;
+            }
+            // --- Move to the next token
+            startToken = this._lexer.peek();
+        }
+        if (!hasUmlElement) {
+            this.reportError("U002", startToken);
+            return null;
+        }
+        return nodes;
+    }
+    parseFragment() {
+        const nodes = [];
+        let startToken = this._lexer.peek();
+        while (!this.isEof) {
+            switch (startToken.type) {
+                case UemlToken_1.UemlTokenType.Comment:
+                    const commentToken = this._lexer.get();
+                    nodes.push(this.createNode("Comment", {
+                        text: commentToken.text,
+                    }, startToken));
+                    break;
+                case UemlToken_1.UemlTokenType.OpenNodeStart:
+                    const element = this.parseElement();
+                    if (!element) {
+                        return null;
+                    }
+                    nodes.push(element);
+                    break;
+                default:
+                    this.reportError("U001", startToken, startToken.text);
+                    return null;
+            }
+            // --- Move to the next token
+            startToken = this._lexer.peek();
+        }
+        return nodes;
+    }
+    /**
+     * Transforms the provided nodes to their component definition
+     * @param nodes Nodes to transform
+     */
+    transformToComponentDef(nodes) {
+        if (!nodes) {
+            const parsedNodes = this.parseComponentElement();
+            if (!parsedNodes)
+                return null;
+            nodes = parsedNodes;
+        }
+        // --- Check that the nodes contains exactly only a single component root element
+        const rootElements = nodes.filter((e) => e.type === "Element");
+        if (rootElements.length !== 1) {
+            this.reportError("T001");
+            return null;
+        }
+        // --- Search for the element, take a note of the preceding comment
+        const index = nodes.findIndex((n) => n.type === "Element");
+        const element = nodes[index];
+        const comment = index > 0 ? nodes[index - 1] : undefined;
+        if (!UemlHelper_1.UCRegex.test(element.id)) {
+            this.reportError("T002");
+            return null;
+        }
+        // --- Done
+        const usesStack = [];
+        return this.transformSingleElement(usesStack, element);
+    }
+    /**
+     * Transforms the provided nodes to their component definition
+     * @param usesStack "Uses" stack
+     * @param nodes Nodes to transform
+     */
+    transformToObject(nodes, usesStack = []) {
+        var _a;
+        if (!nodes) {
+            const parsedNodes = this.parseFragment();
+            if (!parsedNodes)
+                return null;
+            nodes = parsedNodes;
+        }
+        const root = {
+            type: "Element",
+            id: "root",
+            attributes: [
+                {
+                    type: "Attribute",
+                    name: "name",
+                    value: "object",
+                },
+            ],
+            childNodes: nodes,
+        };
+        // --- Done
+        return (_a = this.collectValue(usesStack, root)) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    // ==================================================================================================================
+    // Transform methods
+    transformSingleElement(usesStack, node) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        let component;
+        if (node.id === UemlHelper_1.COMPOUND_COMP_ID) {
+            // --- Validate component name
+            const compoundName = ((_a = node.attributes) !== null && _a !== void 0 ? _a : []).find((attr) => attr.name === "name");
+            if (!compoundName) {
+                this.reportError("T003");
+                return null;
+            }
+            if (!UemlHelper_1.UCRegex.test(compoundName.value)) {
+                this.reportError("T004");
+                return null;
+            }
+            // --- Get "api" attributes
+            let api;
+            const apiAttrs = ((_b = node.attributes) !== null && _b !== void 0 ? _b : []).filter((attr) => attr.startSegment === "api");
+            if (apiAttrs.length > 0) {
+                api = {};
+                apiAttrs.forEach((attr) => {
+                    api[attr.name] = attr.value;
+                });
+            }
+            // --- Get "var" attributes
+            let vars;
+            const varsAttrs = ((_c = node.attributes) !== null && _c !== void 0 ? _c : []).filter((attr) => attr.startSegment === "var");
+            if (varsAttrs.length > 0) {
+                vars = {};
+                varsAttrs.forEach((attr) => {
+                    vars[attr.name] = attr.value;
+                });
+            }
+            // --- Check for nested component
+            const nestedCompound = ((_d = node.childNodes) !== null && _d !== void 0 ? _d : []).find((child) => child.type === "Element" && child.id === UemlHelper_1.COMPOUND_COMP_ID);
+            if (nestedCompound) {
+                this.reportError("T006");
+                return null;
+            }
+            // --- Get the single component definition
+            const nestedComponents = ((_e = node.childNodes) !== null && _e !== void 0 ? _e : []).filter((child) => child.type === "Element" && UemlHelper_1.UCRegex.test(child.id));
+            if (nestedComponents.length === 0) {
+                nestedComponents.push({
+                    type: "Element",
+                    id: "TextNode",
+                    attributes: [
+                        {
+                            type: "Attribute",
+                            name: "value",
+                            value: "",
+                        },
+                    ],
+                });
+            }
+            const nestedVars = ((_f = node.childNodes) !== null && _f !== void 0 ? _f : []).filter((child) => child.type === "Element" && child.id === "var");
+            const childrenToCollect = ((_g = node.childNodes) !== null && _g !== void 0 ? _g : []).filter((child) => child.type === "Element" && !UemlHelper_1.UCRegex.test(child.id) && child.id !== "var");
+            // --- Should we use a Fragment?
+            if (nestedComponents.length > 1 || nestedVars.length > 0) {
+                // --- Wrap the children in a Fragment
+                const fragmentElement = {
+                    type: "Element",
+                    id: "Fragment",
+                    childNodes: [...nestedVars, ...nestedComponents],
+                };
+                const nestedFragment = this.transformSingleElement(usesStack, fragmentElement);
+                component = {
+                    name: compoundName.value,
+                    component: nestedFragment,
+                };
+                if (api) {
+                    component.api = api;
+                }
+                if (vars) {
+                    nestedFragment.vars = Object.assign(Object.assign({}, nestedFragment.vars), vars);
+                }
+            }
+            else {
+                // --- Search for the element, take a note of the preceding comment
+                const element = nestedComponents[0];
+                const nestedComponent = this.transformSingleElement(usesStack, element);
+                // --- Create the component
+                component = {
+                    name: compoundName.value,
+                    component: nestedComponent,
+                };
+                if (api) {
+                    component.api = api;
+                }
+                if (vars) {
+                    nestedComponent.vars = Object.assign(Object.assign({}, nestedComponent.vars), vars);
+                }
+            }
+            const nodeClone = Object.assign({}, node);
+            nodeClone.childNodes = childrenToCollect;
+            this.collectTraits(usesStack, component, nodeClone);
+            return component;
+        }
+        // --- Not a reusable component
+        if (!UemlHelper_1.UCRegex.test(node.id)) {
+            this.reportError("T002");
+            return null;
+        }
+        component = {
+            type: node.id,
+        };
+        // --- Done
+        this.collectTraits(usesStack, component, node);
+        return component;
+    }
+    /**
+     * Collects component traits from attributes and child elements
+     * @param usesStack "Uses" stack
+     * @param comp Component definition
+     * @param element Component element
+     */
+    collectTraits(usesStack, comp, element) {
+        var _a, _b, _c, _d;
+        const isCompound = !isComponent(comp);
+        // --- Process attributes
+        ((_a = element.attributes) !== null && _a !== void 0 ? _a : []).forEach((attr) => {
+            // --- Process the attribute
+            if (attr.namespace) {
+                this.reportError("T021");
+                return;
+            }
+            this.collectAttribute(comp, attr.startSegment, attr.name, attr.value);
+        });
+        let lastComment = null;
+        // --- Process child nodes
+        ((_b = element.childNodes) !== null && _b !== void 0 ? _b : []).forEach((child) => {
+            var _a;
+            if (child.type === "Comment") {
+                lastComment = child;
+            }
+            if (isCompound && child.type === "Element" && UemlHelper_1.UCRegex.test(child.id)) {
+                // --- This is the single nested component definition of a compound component,
+                // --- it is already processed
+                return;
+            }
+            // --- Single text element, consider it a child name
+            if (child.type === "Text" && !isCompound) {
+                comp.children = this.mergeValue(comp.children, child.text);
+            }
+            // --- It should not happen, but just for being safe...
+            if (child.type !== "Element")
+                return;
+            // --- Element name starts with an uppercase letter
+            if (UemlHelper_1.UCRegex.test(child.id) && !isCompound) {
+                // --- This must be a child component
+                const childComponent = this.transformSingleElement(usesStack, child);
+                if (childComponent) {
+                    if (!comp.children) {
+                        comp.children = [childComponent];
+                    }
+                    else {
+                        if (typeof comp.children === "string") {
+                            comp.children = [comp.children, childComponent];
+                        }
+                        else if (Array.isArray(comp.children)) {
+                            comp.children.push(childComponent);
+                        }
+                    }
+                }
+                return;
+            }
+            // --- Element with a lowercase start letter, it must be some traits of the host component
+            switch (child.id) {
+                case "prop":
+                    this.collectElementHelper(usesStack, comp, child, (name) => { var _a; return (isComponent(comp) ? (_a = comp.props) === null || _a === void 0 ? void 0 : _a[name] : undefined); }, (name, value) => {
+                        var _a;
+                        if (!isComponent(comp))
+                            return;
+                        (_a = comp.props) !== null && _a !== void 0 ? _a : (comp.props = {});
+                        comp.props[name] = value;
+                    });
+                    return;
+                case "event":
+                    this.collectElementHelper(usesStack, comp, child, (name) => { var _a; return (isComponent(comp) ? (_a = comp.events) === null || _a === void 0 ? void 0 : _a[name] : undefined); }, (name, value) => {
+                        var _a;
+                        if (!isComponent(comp))
+                            return;
+                        (_a = comp.events) !== null && _a !== void 0 ? _a : (comp.events = {});
+                        comp.events[name] = value;
+                    }, (name) => {
+                        if (UemlHelper_1.onPrefixRegex.test(name)) {
+                            this.reportError("T008", undefined, name);
+                        }
+                    });
+                    return;
+                case "var":
+                    this.collectElementHelper(usesStack, comp, child, (name) => { var _a; return (isComponent(comp) ? (_a = comp.vars) === null || _a === void 0 ? void 0 : _a[name] : undefined); }, (name, value) => {
+                        var _a;
+                        if (!isComponent(comp))
+                            return;
+                        (_a = comp.vars) !== null && _a !== void 0 ? _a : (comp.vars = {});
+                        comp.vars[name] = value;
+                    });
+                    return;
+                case "loaders":
+                    this.collectLoadersElements(usesStack, comp, child);
+                    return;
+                case "uses":
+                    this.collectUsesElements(comp, child);
+                    return;
+                case "api":
+                    this.collectElementHelper(usesStack, comp, child, (name) => { var _a; return (isComponent(comp) ? (_a = comp.api) === null || _a === void 0 ? void 0 : _a[name] : undefined); }, (name, value) => {
+                        var _a;
+                        (_a = comp.api) !== null && _a !== void 0 ? _a : (comp.api = {});
+                        comp.api[name] = value;
+                    });
+                    return;
+                case "script":
+                    if (child.attributes && child.attributes.length > 0) {
+                        this.reportError("T022");
+                        return;
+                    }
+                    if (!child.childNodes || !child.childNodes.length) {
+                        // --- No children, no script
+                        return;
+                    }
+                    if (child.childNodes.length === 1 && child.childNodes[0].type === "Text") {
+                        // --- We have a single text child
+                        (_a = comp.script) !== null && _a !== void 0 ? _a : (comp.script = "");
+                        if (comp.script.length > 0) {
+                            comp.script += "\n";
+                        }
+                        comp.script += child.childNodes[0].text;
+                    }
+                    else {
+                        this.reportError("T023");
+                    }
+                    return;
+                case "metadata":
+                    this.collectMetadataElements(comp);
+                    return;
+                default:
+                    this.reportError("T009", undefined, child.id);
+                    return;
+            }
+        });
+        if (!comp.script || comp.script.trim().length === 0) {
+            // --- No (or whitespace only) script
+            return;
+        }
+        // --- Run the parse and collect on scripts
+        const parser = new Parser_1.Parser(comp.script);
+        try {
+            // --- We parse the module file to catch parsing errors
+            parser.parseStatements();
+            const evalContext = (0, BindingTreeEvaluationContext_1.createEvalContext)({});
+            comp.scriptCollected = (0, code_behind_collect_1.collectCodeBehindFromSource)("Main", comp.script, this.moduleResolver, evalContext);
+        }
+        catch (err) {
+            if (parser.errors && parser.errors.length > 0) {
+                comp.scriptError = parser.errors;
+            }
+            else {
+                comp.scriptError = err;
+            }
+        }
+        // --- We may have module parsing/execution errors
+        const moduleErrors = (_d = (_c = comp.scriptCollected) === null || _c === void 0 ? void 0 : _c.moduleErrors) !== null && _d !== void 0 ? _d : {};
+        if (Object.keys(moduleErrors).length > 0) {
+            comp.scriptError = moduleErrors;
+        }
+    }
+    /**
+     * Process a single component attribute
+     * @param comp Component definition to merge the attribute into
+     * @param startSegment Starts segment name
+     * @param name Attribute name
+     * @param value Attribute value
+     */
+    collectAttribute(comp, startSegment, name, value) {
+        var _a, _b, _c, _d, _e;
+        const isCompound = !isComponent(comp);
+        // --- Handle single-word attributes
+        if (isCompound) {
+            if (startSegment && startSegment !== "api" && startSegment !== "var") {
+                this.reportError("T021");
+                return;
+            }
+            if (name === "name" && !startSegment) {
+                // --- We already processed name
+                return;
+            }
+            // --- Compound components do not have any other attributable props
+            if (!startSegment && !startSegment) {
+                this.reportError("T021", undefined, name);
+            }
+            return;
+        }
+        // --- Do not allow segmented attribute names
+        if (name.indexOf(".") >= 0) {
+            this.reportError("T007", undefined, name);
+            return;
+        }
+        // --- Recognize special attributes by component definition type
+        switch (name) {
+            case "id":
+                comp.uid = value;
+                return;
+            case "testId":
+                comp.testId = value;
+                return;
+            case "when":
+                comp.when = value;
+                return;
+            default:
+                if (startSegment === "var") {
+                    (_a = comp.vars) !== null && _a !== void 0 ? _a : (comp.vars = {});
+                    comp.vars[name] = value;
+                }
+                else if (startSegment === "api") {
+                    (_b = comp.api) !== null && _b !== void 0 ? _b : (comp.api = {});
+                    comp.api[name] = value;
+                }
+                else if (startSegment === "event") {
+                    (_c = comp.events) !== null && _c !== void 0 ? _c : (comp.events = {});
+                    comp.events[name] = value;
+                }
+                else if (UemlHelper_1.onPrefixRegex.test(name)) {
+                    (_d = comp.events) !== null && _d !== void 0 ? _d : (comp.events = {});
+                    const eventName = name[2].toLowerCase() + name.substring(3);
+                    comp.events[eventName] = value;
+                }
+                else {
+                    (_e = comp.props) !== null && _e !== void 0 ? _e : (comp.props = {});
+                    comp.props[name] = value;
+                }
+                return;
+        }
+    }
+    collectElementHelper(usesStack, comp, child, getter, setter, nameValidator) {
+        // --- Compound component do not have a uses
+        var _a;
+        // --- Get the value
+        const valueInfo = this.collectValue(usesStack, child);
+        if (!valueInfo) {
+            return;
+        }
+        // --- Extra name validation, if required so
+        nameValidator === null || nameValidator === void 0 ? void 0 : nameValidator((_a = valueInfo === null || valueInfo === void 0 ? void 0 : valueInfo.name) !== null && _a !== void 0 ? _a : "");
+        const name = valueInfo.name;
+        const value = valueInfo.value;
+        if ((valueInfo === null || valueInfo === void 0 ? void 0 : valueInfo.value) !== undefined) {
+            setter(name, this.mergeValue(getter(name), value));
+        }
+        else {
+            // --- Consider the value to be null; check optional child items
+            const itemValue = this.collectObjectOrArray(usesStack, child.childNodes);
+            let updatedValue = getter(name);
+            updatedValue = this.mergeValue(updatedValue, itemValue);
+            setter(name, updatedValue);
+        }
+    }
+    collectValue(usesStack, element, allowName = true) {
+        var _a, _b, _c, _d;
+        // --- Accept only "name", "value"
+        const nestedComponents = ((_a = element.childNodes) !== null && _a !== void 0 ? _a : []).filter((c) => c.type === "Element" && UemlHelper_1.UCRegex.test(c.id));
+        const nestedElements = ((_b = element.childNodes) !== null && _b !== void 0 ? _b : []).filter((c) => c.type === "Element" && !UemlHelper_1.UCRegex.test(c.id));
+        const attrProps = ((_c = element.attributes) !== null && _c !== void 0 ? _c : []).filter((attr) => propAttrs.indexOf(attr.name) >= 0);
+        if (((_d = element.attributes) !== null && _d !== void 0 ? _d : []).length > attrProps.length) {
+            this.reportError("T011", undefined, element.id);
+            return null;
+        }
+        // --- Validate the "name" usage
+        const nameAttr = attrProps.find((attr) => attr.name === "name");
+        if (allowName) {
+            if (!(nameAttr === null || nameAttr === void 0 ? void 0 : nameAttr.value)) {
+                this.reportError("T012", undefined, element.id);
+                return null;
+            }
+        }
+        else {
+            if (nameAttr) {
+                this.reportError("T018", undefined, element.id);
+                return null;
+            }
+        }
+        const name = nameAttr === null || nameAttr === void 0 ? void 0 : nameAttr.value;
+        // --- Get the value attribute
+        const valueAttr = attrProps.find((attr) => attr.name === "value");
+        if (valueAttr && valueAttr.value === undefined) {
+            this.reportError("T019", undefined, element.id);
+            return null;
+        }
+        // --- Let's handle a special case, when the value is a component definition
+        if (name && nestedComponents.length >= 1) {
+            if (nestedElements.length > 0) {
+                this.reportError("T020");
+                return null;
+            }
+            // --- We expect a component definition here!
+            const nestedComps = nestedComponents.map((nc) => this.transformSingleElement(usesStack, nc));
+            return { name, value: nestedComps.length === 1 ? nestedComps[0] : nestedComps };
+        }
+        // --- At this point, all attributes are ok, let's get the value.
+        let value = valueAttr === null || valueAttr === void 0 ? void 0 : valueAttr.value;
+        if (value === null) {
+            return null;
+        }
+        if (typeof value === "string") {
+            return { name, value };
+        }
+        return { name, value: this.collectObjectOrArray(usesStack, element.childNodes) };
+    }
+    collectLoadersElements(usesStack, comp, loaders) {
+        var _a, _b, _c, _d, _e;
+        if (!isComponent(comp)) {
+            this.reportError("T009", undefined, "loaders");
+            return;
+        }
+        if (isComponent(comp) && ((_b = (_a = loaders === null || loaders === void 0 ? void 0 : loaders.childNodes) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) === 0) {
+            (_c = comp.loaders) !== null && _c !== void 0 ? _c : (comp.loaders = []);
+        }
+        // --- Loaders element must not have attributes
+        if (((_d = loaders.attributes) !== null && _d !== void 0 ? _d : []).length > 0) {
+            this.reportError("T012", undefined, "loaders");
+            return;
+        }
+        // --- Iterate through child elements
+        let lastComment = null;
+        ((_e = loaders.childNodes) !== null && _e !== void 0 ? _e : []).forEach((loader) => {
+            var _a;
+            // --- Take a note of the last comment
+            if (loader.type === "Comment") {
+                lastComment = loader;
+                return;
+            }
+            // --- Test is not supported
+            if (loader.type === "Text") {
+                this.reportError("T010", undefined, "loader");
+                return;
+            }
+            // --- Just for the sake of being sure...
+            if (loader.type !== "Element")
+                return;
+            const loaderDef = this.transformSingleElement(usesStack, loader);
+            // --- Get the uid value
+            if (!loaderDef.uid) {
+                this.reportError("T013");
+                return;
+            }
+            // --- Check props that a loader must not have
+            if (loaderDef.vars) {
+                this.reportError("T014", undefined, "vars");
+                return;
+            }
+            if (loaderDef.loaders) {
+                this.reportError("T014", undefined, "loaders");
+                return;
+            }
+            if (loaderDef.uses) {
+                this.reportError("T014", undefined, "uses");
+                return;
+            }
+            // --- Store this loader
+            (_a = comp.loaders) !== null && _a !== void 0 ? _a : (comp.loaders = []);
+            comp.loaders.push(loaderDef);
+        });
+    }
+    collectUsesElements(comp, uses) {
+        var _a, _b, _c, _d;
+        // --- Compound component do not have a uses
+        if (!isComponent(comp)) {
+            this.reportError("T009", undefined, "uses");
+            return;
+        }
+        const valueAttr = ((_a = uses.attributes) !== null && _a !== void 0 ? _a : []).find((attr) => attr.name === "value");
+        if (!(valueAttr === null || valueAttr === void 0 ? void 0 : valueAttr.value) || ((_c = (_b = uses.attributes) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0) !== 1) {
+            this.reportError("T015", undefined, "uses");
+            return;
+        }
+        // --- Extract the value
+        (_d = comp.uses) !== null && _d !== void 0 ? _d : (comp.uses = valueAttr.value.split(",").map((v) => v.trim()));
+    }
+    collectMetadataElements(comp) {
+        if (isComponent(comp)) {
+            this.reportError("T009", undefined, "meadata");
+            return;
+        }
+    }
+    collectObjectOrArray(usesStack, children) {
+        let result = null;
+        // --- No children, it's a null object
+        if (!children)
+            return result;
+        let nestedElementType = null;
+        children.forEach((child) => {
+            if (child.type === "Text") {
+                result = this.mergeValue(result, child.text);
+                return;
+            }
+            if (child.type !== "Element")
+                return;
+            // --- The only element names we accept are "field" or "item"
+            if (child.id !== "field" && child.id !== "item") {
+                this.reportError("T016");
+                return;
+            }
+            if (child.id === "field") {
+                if (!nestedElementType) {
+                    // --- First nested element is "field", so we have an object
+                    nestedElementType = child.id;
+                    result = {};
+                }
+                else if (nestedElementType !== child.id) {
+                    this.reportError("T017");
+                    return;
+                }
+            }
+            else if (child.id === "item") {
+                if (!nestedElementType) {
+                    // --- First nested element is "item", so we have an array
+                    nestedElementType = child.id;
+                    result = [];
+                }
+                else if (nestedElementType !== child.id) {
+                    this.reportError("T017");
+                    return;
+                }
+            }
+            // --- Get the field value
+            let valueInfo = this.collectValue(usesStack, child, child.id === "field");
+            if (!valueInfo) {
+                return null;
+            }
+            // --- Does the field have a value?
+            if (nestedElementType === "field") {
+                result[valueInfo.name] = valueInfo.value;
+            }
+            else {
+                result.push(valueInfo.value);
+            }
+        });
+        return result;
+    }
+    mergeValue(oldValue, itemValue) {
+        if (oldValue) {
+            if (Array.isArray(oldValue)) {
+                if (typeof oldValue === "string") {
+                    return [oldValue, itemValue];
+                }
+                else {
+                    oldValue.push(itemValue);
+                    return oldValue;
+                }
+            }
+            else {
+                return [oldValue, itemValue];
+            }
+        }
+        else {
+            return itemValue;
+        }
+    }
+    // ==================================================================================================================
+    // Parsing methods
+    /**
+     * Parses an UEML elements
+     *
+     * uemlElement
+     *   : "<" id uemlAttribute* ">" (uemlLiteral? | uemlElement*) "</" id ">"
+     *   | "<" id uemlAttribute* "/>"
+     *   ;
+     *
+     */
+    parseElement() {
+        let startToken = this._lexer.peek();
+        let attributes = [];
+        // --- Test the open node start token
+        if (startToken.type !== UemlToken_1.UemlTokenType.OpenNodeStart) {
+            this.reportError("U003", startToken);
+            return null;
+        }
+        // --- Get the node id
+        this._lexer.get();
+        let namespace = "";
+        let idToken = this._lexer.peek();
+        if (idToken.type !== UemlToken_1.UemlTokenType.Identifier) {
+            this.reportError("U004", idToken);
+            return null;
+        }
+        // --- Check for namespace
+        this._lexer.get();
+        if (this._lexer.peek().type === UemlToken_1.UemlTokenType.Colon) {
+            this._lexer.get();
+            namespace = idToken.text;
+            idToken = this._lexer.peek();
+            if (idToken.type !== UemlToken_1.UemlTokenType.Identifier) {
+                this.reportError("U004", idToken);
+                return null;
+            }
+            this._lexer.get();
+        }
+        // --- Parse attributes
+        let nextToken = this._lexer.peek();
+        // --- Skip comment
+        while (nextToken.type === UemlToken_1.UemlTokenType.Comment) {
+            this._lexer.get();
+            nextToken = this._lexer.peek();
+        }
+        // --- Get the next attribute
+        while (nextToken.type === UemlToken_1.UemlTokenType.Identifier) {
+            // --- Seems to be an attribute value
+            const attribute = this.parseAttribute();
+            if (attribute) {
+                if (attributes.find((attr) => attr.name === attribute.name)) {
+                    this.reportError("U012", nextToken, attribute.name);
+                    return null;
+                }
+                if (UemlHelper_1.UCRegex.test(attribute.name)) {
+                    this.reportError("U013");
+                    return null;
+                }
+                attributes.push(attribute);
+            }
+            nextToken = this._lexer.peek();
+            // --- Skip comment
+            while (nextToken.type === UemlToken_1.UemlTokenType.Comment) {
+                this._lexer.get();
+                nextToken = this._lexer.peek();
+            }
+        }
+        // --- Test the closing of the node
+        if (nextToken.type === UemlToken_1.UemlTokenType.NodeClose) {
+            // --- This node is closed, return it
+            this._lexer.get();
+            return this.createNode("Element", {
+                id: idToken.text,
+                namespace,
+                attributes,
+            }, nextToken);
+        }
+        // --- Check the closing token of the node
+        if (nextToken.type !== UemlToken_1.UemlTokenType.NodeEnd) {
+            this.reportError("U006", nextToken);
+            return null;
+        }
+        this._lexer.get();
+        // --- Get the nested children or text
+        const isComponentElement = UemlHelper_1.UCRegex.test(idToken.text);
+        const shouldUseTextNode = isComponentElement || idToken.text === "prop";
+        const shouldPreserveWhitespace = idToken.text === "event" || idToken.text === "api" || idToken.text === "script";
+        let childNodes = this.parseElementChildren(shouldPreserveWhitespace, shouldUseTextNode);
+        if (!childNodes) {
+            return null;
+        }
+        // --- Separate helper nodes from <script> and component children
+        const helperNodes = childNodes.filter((n) => n.type === "Element" && !UemlHelper_1.UCRegex.test(n.id) && n.id !== "script");
+        const otherNodes = childNodes.filter((n) => helperNodes.indexOf(n) < 0);
+        const hasScript = otherNodes.some((n) => n.type === "Element" && n.id === "script");
+        const hasComponent = otherNodes.some((n) => n.type === "Element" && UemlHelper_1.UCRegex.test(n.id));
+        // --- Wrap with fragment if needed
+        if (hasComponent && hasScript) {
+            const fragmentElement = {
+                type: "Element",
+                id: "Fragment",
+                childNodes: otherNodes,
+            };
+            childNodes = [...helperNodes, fragmentElement];
+        }
+        // --- Get the start token of the closing tag
+        const closeToken = this._lexer.peek();
+        if (closeToken.type !== UemlToken_1.UemlTokenType.CloseNodeStart) {
+            this.reportError("U005", closeToken);
+            return null;
+        }
+        // --- Test closing node identifier
+        this._lexer.get();
+        let closeNamespace = "";
+        let closeIdToken = this._lexer.peek();
+        if (closeIdToken.type !== UemlToken_1.UemlTokenType.Identifier) {
+            this.reportError("U004", closeIdToken);
+            return null;
+        }
+        // --- Check for closing namespace
+        this._lexer.get();
+        if (this._lexer.peek().type === UemlToken_1.UemlTokenType.Colon) {
+            this._lexer.get();
+            closeNamespace = closeIdToken.text;
+            closeIdToken = this._lexer.peek();
+            if (closeIdToken.type !== UemlToken_1.UemlTokenType.Identifier) {
+                this.reportError("U004", closeIdToken);
+                return null;
+            }
+            this._lexer.get();
+        }
+        // --- The start end closing namespace must match
+        if (namespace !== closeNamespace) {
+            this.reportError("U014", closeIdToken, namespace, closeNamespace);
+            return null;
+        }
+        // --- The start end closing ID must match
+        if (idToken.text !== closeIdToken.text) {
+            this.reportError("U007", closeIdToken, idToken.text, closeIdToken.text);
+            return null;
+        }
+        // --- Check the element's final token
+        const finalToken = this._lexer.peek();
+        if (finalToken.type !== UemlToken_1.UemlTokenType.NodeEnd) {
+            this.reportError("U008", finalToken);
+            return null;
+        }
+        // --- Done.
+        this._lexer.get();
+        return this.createNode("Element", {
+            id: idToken.text,
+            namespace,
+            attributes,
+            childNodes,
+        }, startToken);
+    }
+    /**
+     * Parses an UEML attribute
+     *
+     * uemlAttribute
+     *   : id "=" (singleWord | stringLiteral)
+     *   ;
+     */
+    parseAttribute() {
+        let namespace;
+        let name;
+        const startToken = this._lexer.peek();
+        if (startToken.type !== UemlToken_1.UemlTokenType.Identifier) {
+            this.reportError("U009", startToken);
+            return null;
+        }
+        name = startToken.text;
+        // --- Check for type spec
+        this._lexer.get();
+        let nextToken = this._lexer.peek();
+        if (nextToken.type === UemlToken_1.UemlTokenType.Colon) {
+            this._lexer.get();
+            namespace = name;
+            const nameToken = this._lexer.peek();
+            if (nameToken.type !== UemlToken_1.UemlTokenType.Identifier) {
+                this.reportError("U009", nameToken);
+                return null;
+            }
+            name = nameToken.text;
+            this._lexer.get();
+            nextToken = this._lexer.peek();
+        }
+        // --- Check segments
+        const segments = name.split(".");
+        if (segments.length > 2) {
+            this.reportError("T007", startToken, name);
+            return null;
+        }
+        let startSegment;
+        if (segments.length === 2) {
+            startSegment = segments[0];
+            name = segments[1];
+            if (name.trim() === "") {
+                this.reportError("T007", startToken, name);
+                return null;
+            }
+        }
+        // --- ID ok, check for "="
+        let value;
+        if (nextToken.type === UemlToken_1.UemlTokenType.Equal) {
+            // --- Get the value
+            this._lexer.get();
+            const valueToken = this._lexer.peek();
+            if (valueToken.type === UemlToken_1.UemlTokenType.StringLiteral) {
+                value = this.parseStringLiteral(valueToken.text);
+            }
+            else {
+                this.reportError("U011", valueToken);
+                return null;
+            }
+            this._lexer.get();
+        }
+        else {
+            this.reportError("U010", nextToken);
+            return null;
+        }
+        // --- Done
+        return this.createNode("Attribute", {
+            namespace,
+            startSegment,
+            name,
+            value,
+        }, startToken);
+    }
+    // --- Parses the nested children of an element
+    parseElementChildren(preserveWhitespace, useTextNode) {
+        var _a, _b, _c;
+        const childNodes = [];
+        let found = false;
+        let disallowTextLike = false;
+        while (true) {
+            let nextToken = this._lexer.peekNested();
+            if (nextToken.type === UemlToken_1.UemlTokenType.Eof) {
+                return childNodes;
+            }
+            let textAsHardLiteral = false;
+            switch (nextToken.type) {
+                case UemlToken_1.UemlTokenType.CloseNodeStart:
+                    // --- No more nested child to parse
+                    found = true;
+                    break;
+                case UemlToken_1.UemlTokenType.Comment:
+                    childNodes.push(this.createNode("Comment", { text: nextToken.text.trim() }, nextToken));
+                    this._lexer.get();
+                    disallowTextLike = false;
+                    break;
+                case UemlToken_1.UemlTokenType.OpenNodeStart:
+                    const childNode = this.parseElement();
+                    if (childNode) {
+                        childNodes.push(childNode);
+                    }
+                    disallowTextLike = false;
+                    break;
+                case UemlToken_1.UemlTokenType.ScriptLiteral: {
+                    this._lexer.get();
+                    let text = nextToken.text.trim();
+                    text = text.substring(UemlLexer_1.SCRIPT_LITERAL_START.length, text.length - UemlLexer_1.SCRIPT_LITERAL_END.length);
+                    childNodes.push(this.createNode("Element", {
+                        id: "script",
+                        attributes: [],
+                        childNodes: [
+                            this.createNode("Text", {
+                                text,
+                            }, nextToken, nextToken),
+                        ],
+                    }, nextToken));
+                    break;
+                }
+                case UemlToken_1.UemlTokenType.HardLiteral:
+                case UemlToken_1.UemlTokenType.NestedText:
+                case UemlToken_1.UemlTokenType.StringLiteral:
+                case UemlToken_1.UemlTokenType.Identifier:
+                    if (disallowTextLike && nextToken.type !== UemlToken_1.UemlTokenType.HardLiteral) {
+                        this.reportError("U015", nextToken, (_c = (_b = (_a = nextToken.text) === null || _a === void 0 ? void 0 : _a.trim()) === null || _b === void 0 ? void 0 : _b.substring(1, 100)) !== null && _c !== void 0 ? _c : "");
+                        return null;
+                    }
+                    disallowTextLike =
+                        nextToken.type === UemlToken_1.UemlTokenType.StringLiteral || nextToken.type === UemlToken_1.UemlTokenType.NestedText;
+                    let text = nextToken.text;
+                    if (nextToken.type === UemlToken_1.UemlTokenType.StringLiteral) {
+                        let literalText = nextToken.text;
+                        if (!preserveWhitespace) {
+                            literalText = literalText.trim();
+                            literalText = literalText.substring(1, literalText.length - 1).replace(/\s+/g, " ");
+                        }
+                        const wrapper = nextToken.text.trim()[0];
+                        text = this.parseStringLiteral(`${wrapper}${literalText}${wrapper}`);
+                    }
+                    else if (nextToken.type === UemlToken_1.UemlTokenType.HardLiteral) {
+                        if (!preserveWhitespace) {
+                            text = nextToken.text.trim();
+                            text = text.substring(UemlLexer_1.HARD_LITERAL_START.length, text.length - UemlLexer_1.HARD_LITERAL_END.length);
+                        }
+                        textAsHardLiteral = true;
+                    }
+                    else {
+                        if (!preserveWhitespace) {
+                            text = text.replace(/\s+/g, " ");
+                        }
+                    }
+                    childNodes.push(useTextNode
+                        ? this.createNode("Element", {
+                            id: textAsHardLiteral ? "TextNodeCData" : "TextNode",
+                            attributes: [
+                                {
+                                    type: "Attribute",
+                                    name: "value",
+                                    value: text,
+                                },
+                            ],
+                        }, nextToken)
+                        : this.createNode("Text", {
+                            text,
+                        }, nextToken));
+                    this._lexer.get();
+                    break;
+                default:
+                    found = true;
+                    break;
+            }
+            if (found) {
+                // --- No more nested element to parse
+                break;
+            }
+        }
+        // --- Preprocess text-like children
+        const processedChildNodes = [];
+        let text = "";
+        let useCData = false;
+        for (const childNode of childNodes) {
+            if (childNode.type === "Element" && (childNode.id === "TextNode" || childNode.id === "TextNodeCData")) {
+                // --- This is a TextNode, it behaves just like text
+                text += childNode.attributes[0].value;
+                useCData = childNode.id === "TextNodeCData";
+            }
+            else if (childNode.type === "Element" || childNode.type === "Comment") {
+                // --- This is a component/helper node or a comment, so store the previously collected text
+                storeText(false);
+                // --- Store the node
+                processedChildNodes.push(childNode);
+            }
+            else if (childNode.type === "Text") {
+                // --- Append the text
+                text += childNode.text;
+            }
+        }
+        // --- We may have a pending (not stored text node)
+        storeText(useCData);
+        // --- Done.
+        return processedChildNodes;
+        // --- Store the processed text
+        function storeText(useCData) {
+            if (text) {
+                processedChildNodes.push(useTextNode
+                    ? {
+                        type: "Element",
+                        id: useCData ? "TextNodeCData" : "TextNode",
+                        attributes: [
+                            {
+                                type: "Attribute",
+                                name: "value",
+                                value: text,
+                            },
+                        ],
+                    }
+                    : {
+                        type: "Text",
+                        text: text,
+                    });
+                text = "";
+            }
+        }
+    }
+    // ==========================================================================
+    // Helpers
+    /**
+     * Reports the specified error
+     * @param errorCode Error code
+     * @param token Token that represents the error's position
+     * @param options Error message options
+     */
+    reportError(errorCode, token, ...options) {
+        var _a;
+        let errorText = (_a = ParserError_1.errorMessages[errorCode]) !== null && _a !== void 0 ? _a : "Unknown error";
+        if (options) {
+            options.forEach((o, idx) => (errorText = replace(errorText, `{${idx}}`, o.toString())));
+        }
+        if (!token) {
+            token = this._lexer.peek();
+        }
+        this._parseErrors.push({
+            code: errorCode,
+            text: errorText,
+            line: token.location.startLine,
+            column: token.location.startColumn,
+            position: token.location.startPosition,
+        });
+        throw new ParserError_1.ParserError(errorText, errorCode);
+        function replace(input, placeholder, replacement) {
+            do {
+                input = input.replace(placeholder, replacement);
+            } while (input.includes(placeholder));
+            return input;
+        }
+    }
+    /**
+     * Creates an expression node
+     * @param type Expression type
+     * @param stump Stump properties
+     * @param startToken The token that starts the expression
+     * @param endToken The token that ends the expression
+     * @param source Expression source code to store to the node
+     */
+    createNode(type, stump, startToken, endToken, source) {
+        // if (!endToken) {
+        //   endToken = this._lexer.peek();
+        // }
+        const startPosition = startToken.location.startPosition;
+        const endPosition = endToken ? endToken.location.startPosition : this._lexer.input.position;
+        return Object.assign({}, stump, {
+            type,
+            startPosition,
+            endPosition,
+            startLine: startToken.location.startLine,
+            startColumn: startToken.location.startColumn,
+            endLine: endToken ? endToken.location.endLine : this._lexer.input.line,
+            endColumn: endToken ? endToken.location.endColumn : this._lexer.input.column,
+            source: source !== null && source !== void 0 ? source : this.getSource(startToken, endToken),
+        });
+    }
+    /**
+     * Gets the source code for the specified token range
+     * @param start Start token
+     * @param end Optional end token
+     * @returns The source code for the token range
+     */
+    getSource(start, end) {
+        return this.source.substring(start.location.startPosition, end ? end.location.startPosition : this._lexer.input.position);
+    }
+    /**
+     * Converts a string token to intrinsic string
+     * @param text Literal text to parse
+     */
+    parseStringLiteral(text) {
+        const input = text.length < 2 ? "" : text.substring(1, text.length - 1);
+        let result = "";
+        let state = StrParseState.Normal;
+        let collect = 0;
+        for (const ch of input) {
+            switch (state) {
+                case StrParseState.Normal:
+                    if (ch === "\\") {
+                        state = StrParseState.Backslash;
+                    }
+                    else {
+                        result += ch;
+                    }
+                    break;
+                case StrParseState.Backslash:
+                    state = StrParseState.Normal;
+                    switch (ch) {
+                        case "b":
+                            result += "\b";
+                            break;
+                        case "f":
+                            result += "\f";
+                            break;
+                        case "n":
+                            result += "\n";
+                            break;
+                        case "r":
+                            result += "\r";
+                            break;
+                        case "t":
+                            result += "\t";
+                            break;
+                        case "v":
+                            result += "\v";
+                            break;
+                        case "S":
+                            result += "\xa0";
+                            break;
+                        case "0":
+                            result += String.fromCharCode(0x00);
+                            break;
+                        case "'":
+                            result += "'";
+                            break;
+                        case '"':
+                            result += '"';
+                            break;
+                        case "\\":
+                            result += "\\";
+                            break;
+                        case "x":
+                            state = StrParseState.X;
+                            break;
+                        case "u":
+                            state = StrParseState.UX1;
+                            break;
+                        default:
+                            result += "\\" + ch;
+                            break;
+                    }
+                    break;
+                case StrParseState.X:
+                    if (isHexadecimal(ch)) {
+                        collect = parseInt(ch, 16);
+                        state = StrParseState.Xh;
+                    }
+                    else {
+                        result += "x";
+                        state = StrParseState.Normal;
+                    }
+                    break;
+                case StrParseState.Xh:
+                    if (isHexadecimal(ch)) {
+                        collect = collect * 0x10 + parseInt(ch, 16);
+                        result += String.fromCharCode(collect);
+                        state = StrParseState.Normal;
+                    }
+                    else {
+                        result += String.fromCharCode(collect);
+                        result += ch;
+                        state = StrParseState.Normal;
+                    }
+                    break;
+                case StrParseState.UX1:
+                    if (ch === "{") {
+                        state = StrParseState.Ucp1;
+                        break;
+                    }
+                    if (isHexadecimal(ch)) {
+                        collect = parseInt(ch, 16);
+                        state = StrParseState.UX2;
+                    }
+                    else {
+                        result += "x";
+                        state = StrParseState.Normal;
+                    }
+                    break;
+                case StrParseState.UX2:
+                    if (isHexadecimal(ch)) {
+                        collect = collect * 0x10 + parseInt(ch, 16);
+                        state = StrParseState.UX3;
+                    }
+                    else {
+                        result += String.fromCharCode(collect);
+                        result += ch;
+                        state = StrParseState.Normal;
+                    }
+                    break;
+                case StrParseState.UX3:
+                    if (isHexadecimal(ch)) {
+                        collect = collect * 0x10 + parseInt(ch, 16);
+                        state = StrParseState.UX4;
+                    }
+                    else {
+                        result += String.fromCharCode(collect);
+                        result += ch;
+                        state = StrParseState.Normal;
+                    }
+                    break;
+                case StrParseState.UX4:
+                    if (isHexadecimal(ch)) {
+                        collect = collect * 0x10 + parseInt(ch, 16);
+                        result += String.fromCharCode(collect);
+                        state = StrParseState.Normal;
+                    }
+                    else {
+                        result += String.fromCharCode(collect);
+                        result += ch;
+                        state = StrParseState.Normal;
+                    }
+                    break;
+                case StrParseState.Ucp1:
+                    if (isHexadecimal(ch)) {
+                        collect = parseInt(ch, 16);
+                        state = StrParseState.Ucp2;
+                    }
+                    else {
+                        result += "x";
+                        state = StrParseState.Normal;
+                    }
+                    break;
+                case StrParseState.Ucp2:
+                    if (isHexadecimal(ch)) {
+                        collect = collect * 0x10 + parseInt(ch, 16);
+                        state = StrParseState.Ucp3;
+                    }
+                    else {
+                        result += String.fromCharCode(collect);
+                        result += ch;
+                        state = StrParseState.Normal;
+                    }
+                    break;
+                case StrParseState.Ucp3:
+                    if (isHexadecimal(ch)) {
+                        collect = collect * 0x10 + parseInt(ch, 16);
+                        state = StrParseState.Ucp4;
+                    }
+                    else {
+                        result += String.fromCharCode(collect);
+                        result += ch;
+                        state = StrParseState.Normal;
+                    }
+                    break;
+                case StrParseState.Ucp4:
+                    if (isHexadecimal(ch)) {
+                        collect = collect * 0x10 + parseInt(ch, 16);
+                        state = StrParseState.Ucp5;
+                    }
+                    else {
+                        result += String.fromCharCode(collect);
+                        result += ch;
+                        state = StrParseState.Normal;
+                    }
+                    break;
+                case StrParseState.Ucp5:
+                    if (isHexadecimal(ch)) {
+                        collect = collect * 0x10 + parseInt(ch, 16);
+                        state = StrParseState.Ucp6;
+                    }
+                    else {
+                        result += String.fromCharCode(collect);
+                        result += ch;
+                        state = StrParseState.Normal;
+                    }
+                    break;
+                case StrParseState.Ucp6:
+                    if (isHexadecimal(ch)) {
+                        collect = collect * 0x10 + parseInt(ch, 16);
+                        state = StrParseState.UcpTail;
+                    }
+                    else {
+                        result += String.fromCharCode(collect);
+                        result += ch;
+                        state = StrParseState.Normal;
+                    }
+                    break;
+                case StrParseState.UcpTail:
+                    result += String.fromCharCode(collect);
+                    if (ch !== "}") {
+                        result += ch;
+                    }
+                    state = StrParseState.Normal;
+                    break;
+            }
+        }
+        // --- Handle the final machine state
+        switch (state) {
+            case StrParseState.Backslash:
+                result += "\\";
+                break;
+            case StrParseState.X:
+                result += "x";
+                break;
+            case StrParseState.Xh:
+                result += String.fromCharCode(collect);
+                break;
+        }
+        // --- Done
+        return result;
+        function isHexadecimal(ch) {
+            return (ch >= "0" && ch <= "9") || (ch >= "a" && ch <= "f") || (ch >= "A" && ch <= "F");
+        }
+    }
+}
+exports.UemlParser = UemlParser;
+/**
+ * States of the string parsing
+ */
+var StrParseState;
+(function (StrParseState) {
+    StrParseState[StrParseState["Normal"] = 0] = "Normal";
+    StrParseState[StrParseState["Backslash"] = 1] = "Backslash";
+    StrParseState[StrParseState["X"] = 2] = "X";
+    StrParseState[StrParseState["Xh"] = 3] = "Xh";
+    StrParseState[StrParseState["UX1"] = 4] = "UX1";
+    StrParseState[StrParseState["UX2"] = 5] = "UX2";
+    StrParseState[StrParseState["UX3"] = 6] = "UX3";
+    StrParseState[StrParseState["UX4"] = 7] = "UX4";
+    StrParseState[StrParseState["Ucp1"] = 8] = "Ucp1";
+    StrParseState[StrParseState["Ucp2"] = 9] = "Ucp2";
+    StrParseState[StrParseState["Ucp3"] = 10] = "Ucp3";
+    StrParseState[StrParseState["Ucp4"] = 11] = "Ucp4";
+    StrParseState[StrParseState["Ucp5"] = 12] = "Ucp5";
+    StrParseState[StrParseState["Ucp6"] = 13] = "Ucp6";
+    StrParseState[StrParseState["UcpTail"] = 14] = "UcpTail";
+})(StrParseState || (StrParseState = {}));
+const propAttrs = ["name", "value"];
+// --- Gets the content text of a comment element
+function getCommentText(comment) {
+    return comment.text.substring("<!--".length, comment.text.length - "-->".length);
+}
+function isComponent(obj) {
+    return obj.type;
+}