xmlui 0.4.1 → 0.4.2-beta.2

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

@@ -1,1439 +0,0 @@
-"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;
-}