xmlui 0.11.3 → 0.11.6

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

@@ -1,1131 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CORE_NAMESPACE_VALUE = exports.onPrefixRegex = exports.UCRegex = exports.COMPOUND_COMP_ID = void 0;
-exports.nodeToComponentDef = nodeToComponentDef;
-exports.stripOnPrefix = stripOnPrefix;
-const code_behind_collect_1 = require("../scripting/code-behind-collect");
-const syntax_node_1 = require("./syntax-node");
-const syntax_kind_1 = require("./syntax-kind");
-const ParserError_1 = require("./ParserError");
-const Parser_1 = require("../scripting/Parser");
-const CharacterCodes_1 = require("./CharacterCodes");
-exports.COMPOUND_COMP_ID = "Component";
-exports.UCRegex = /^[A-Z]/;
-exports.onPrefixRegex = /^on[A-Z]/;
-const propAttrs = ["name", "value"];
-const CDATA_PREFIX_LEN = 9;
-const CDATA_POSTFIX_LEN = 3;
-const COMPONENT_NAMESPACE_SCHEME = "component-ns";
-const APP_NS_KEY = "app-ns";
-const APP_NS_VALUE = "#app-ns";
-const CORE_NS_KEY = "core-ns";
-exports.CORE_NAMESPACE_VALUE = "#xmlui-core-ns";
-const HelperNode = {
-    property: "property",
-    event: "event",
-    variable: "variable",
-    loaders: "loaders",
-    uses: "uses",
-    method: "method",
-    item: "item",
-    field: "field",
-};
-let lastParseId = 0;
-function nodeToComponentDef(node, originalGetText, fileId) {
-    const getText = (node) => {
-        var _a;
-        return (_a = node.text) !== null && _a !== void 0 ? _a : originalGetText(node);
-    };
-    const element = getTopLvlElement(node, getText);
-    const preppedElement = prepNode(element);
-    const usesStack = [];
-    const namespaceStack = [];
-    return transformTopLvlElement(usesStack, preppedElement);
-    function transformTopLvlElement(usesStack, node) {
-        const name = getNamespaceResolvedComponentName(node, getText, namespaceStack);
-        if (name === exports.COMPOUND_COMP_ID) {
-            return collectCompoundComponent(node);
-        }
-        let component = {
-            type: name,
-            debug: {
-                source: {
-                    start: node.start,
-                    end: node.end,
-                    fileId,
-                },
-            },
-        };
-        // --- Done
-        collectTraits(usesStack, component, node);
-        return component;
-    }
-    function transformInnerElement(usesStack, node) {
-        const name = getNamespaceResolvedComponentName(node, getText, namespaceStack);
-        if (name === exports.COMPOUND_COMP_ID) {
-            reportError("T006");
-        }
-        let component = {
-            type: name,
-            debug: {
-                source: {
-                    start: node.start,
-                    end: node.end,
-                    fileId,
-                },
-            },
-        };
-        // --- Done
-        collectTraits(usesStack, component, node);
-        return component;
-    }
-    function collectCompoundComponent(node) {
-        const attrs = getAttributes(node).map(segmentAttr);
-        // --- Validate component name
-        const compoundName = attrs.find((attr) => attr.name === "name");
-        if (!compoundName) {
-            reportError("T003");
-        }
-        if (!exports.UCRegex.test(compoundName.value)) {
-            reportError("T004");
-        }
-        const codeBehind = attrs.find((attr) => attr.name === "codeBehind");
-        // --- Get "method" attributes
-        let api;
-        const apiAttrs = attrs.filter((attr) => attr.startSegment === "method");
-        if (apiAttrs.length > 0) {
-            api = {};
-            apiAttrs.forEach((attr) => {
-                api[attr.name] = attr.value;
-            });
-        }
-        // --- Get var attributes
-        let vars;
-        const varsAttrs = attrs.filter((attr) => attr.startSegment === "var");
-        if (varsAttrs.length > 0) {
-            vars = {};
-            varsAttrs.forEach((attr) => {
-                vars[attr.name] = attr.value;
-            });
-        }
-        const children = getChildNodes(node);
-        // --- Get the single component definition
-        const nestedComponents = children.filter((child) => child.kind === syntax_kind_1.SyntaxKind.ElementNode && !(getComponentName(child, getText) in HelperNode));
-        if (nestedComponents.length === 0) {
-            nestedComponents.push(createTextNodeElement(""));
-        }
-        const nonVarHelperNodes = [];
-        const nestedVars = [];
-        for (let child of children) {
-            if (child.kind === syntax_kind_1.SyntaxKind.ElementNode) {
-                const childName = getComponentName(child, getText);
-                if (childName === HelperNode.variable) {
-                    nestedVars.push(child);
-                }
-                else if (childName in HelperNode) {
-                    nonVarHelperNodes.push(child);
-                }
-            }
-        }
-        // --- Should we wrap with a Fragment?
-        let element;
-        if (nestedComponents.length > 1 || nestedVars.length > 0) {
-            element = wrapWithFragment([...nestedVars, ...nestedComponents]);
-        }
-        else {
-            element = nestedComponents[0];
-        }
-        namespaceStack.push(new Map());
-        // --- Get collect namespace attributes
-        const nsAttrs = attrs
-            .filter((attr) => attr.namespace === "xmlns")
-            .forEach((attr) => {
-            addToNamespaces(namespaceStack, element, attr.unsegmentedName, attr.value);
-        });
-        let nestedComponent = transformInnerElement(usesStack, element);
-        namespaceStack.pop();
-        const component = {
-            name: compoundName.value,
-            component: nestedComponent,
-            debug: {
-                source: {
-                    start: node.start,
-                    end: node.end,
-                    fileId,
-                },
-            },
-        };
-        if (api) {
-            component.api = api;
-        }
-        if (vars) {
-            nestedComponent.vars = Object.assign(Object.assign({}, nestedComponent.vars), vars);
-        }
-        if (codeBehind) {
-            component.codeBehind = codeBehind.value;
-        }
-        nestedComponent.debug = {
-            source: {
-                start: element.start,
-                end: element.end,
-                fileId,
-            },
-        };
-        const nodeClone = withNewChildNodes(node, nonVarHelperNodes);
-        collectTraits(usesStack, component, nodeClone);
-        return component;
-    }
-    /**
-     * Collects component traits from attributes and child elements
-     * @param comp Component definition
-     * @param element Component element
-     */
-    function collectTraits(usesStack, comp, element) {
-        var _a, _b;
-        const isCompound = !isComponent(comp);
-        const attributes = getAttributes(element);
-        namespaceStack.push(new Map());
-        // --- Process attributes
-        attributes.forEach((attr) => {
-            // --- Process the attribute
-            collectAttribute(comp, attr);
-        });
-        const childNodes = getChildNodes(element);
-        // --- Process child nodes
-        childNodes.forEach((child) => {
-            var _a;
-            if (child.kind === syntax_kind_1.SyntaxKind.Script) {
-                if (getAttributes(child).length > 0) {
-                    reportError("T022");
-                }
-                const scriptText = getText(child);
-                const scriptContent = scriptText.slice(scriptText.indexOf(">") + 1, scriptText.lastIndexOf("</"));
-                (_a = comp.script) !== null && _a !== void 0 ? _a : (comp.script = "");
-                if (comp.script.length > 0) {
-                    comp.script += "\n";
-                }
-                comp.script += scriptContent;
-                return;
-            }
-            // --- Single text element, consider it a child name
-            if (child.kind === syntax_kind_1.SyntaxKind.TextNode && !isCompound) {
-                comp.children = mergeValue(comp.children, getText(child));
-                return;
-            }
-            const childName = getComponentName(child, getText);
-            if (isCompound && child.kind === syntax_kind_1.SyntaxKind.ElementNode && !(childName in HelperNode)) {
-                // --- This is the single nested component definition of a compound component,
-                // --- it is already processed
-                return;
-            }
-            // --- Element name starts with an uppercase letter
-            if (!(childName in HelperNode) && !isCompound) {
-                // if (UCRegex.test(childName) && !isCompound) {
-                // --- This must be a child component
-                // maybe here or in the transformInnerElement function, after the compound comp check
-                const childComponent = transformInnerElement(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 (childName) {
-                case "property":
-                    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":
-                    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] = parseEvent(value);
-                    }, (name) => {
-                        if (exports.onPrefixRegex.test(name)) {
-                            reportError("T008", name);
-                        }
-                    });
-                    return;
-                case HelperNode.variable:
-                    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":
-                    collectLoadersElements(usesStack, comp, child);
-                    return;
-                case "uses":
-                    collectUsesElements(comp, child);
-                    return;
-                case "method":
-                    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;
-                default:
-                    reportError("T009", childName);
-                    return;
-            }
-        });
-        namespaceStack.pop();
-        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();
-            comp.scriptCollected = (0, code_behind_collect_1.collectCodeBehindFromSource)("Main", comp.script);
-        }
-        catch (err) {
-            if (parser.errors && parser.errors.length > 0) {
-                const errMsg = parser.errors[0];
-                throw new ParserError_1.ParserError(`${errMsg.text} [${errMsg.line}: ${errMsg.column}]`, errMsg.code);
-            }
-            else {
-                comp.scriptError = err;
-            }
-        }
-        // --- We may have module parsing/execution errors
-        const moduleErrors = (_b = (_a = comp.scriptCollected) === null || _a === void 0 ? void 0 : _a.moduleErrors) !== null && _b !== void 0 ? _b : {};
-        if (Object.keys(moduleErrors).length > 0) {
-            comp.scriptError = moduleErrors;
-        }
-    }
-    function collectAttribute(comp, attr) {
-        var _a, _b, _c, _d, _e;
-        const { namespace, startSegment, name, value, unsegmentedName: nsKey } = segmentAttr(attr);
-        if (namespace === "xmlns") {
-            return addToNamespaces(namespaceStack, comp, nsKey, value);
-        }
-        const isCompound = !isComponent(comp);
-        // --- Handle single-word attributes
-        if (isCompound) {
-            if (startSegment && startSegment !== "method" && startSegment !== "var") {
-                reportError("T021");
-                return;
-            }
-            if (name === "name" && !startSegment) {
-                // --- We already processed name
-                return;
-            }
-            if (name === "codeBehind" && !startSegment) {
-                // --- We already processed codeBehind
-                return;
-            }
-            // --- Compound components do not have any other attributable props
-            if (!startSegment && name) {
-                reportError("T021", 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;
-            case "uses":
-                comp.uses = splitUsesValue(value);
-                return;
-            default:
-                if (startSegment === "var") {
-                    (_a = comp.vars) !== null && _a !== void 0 ? _a : (comp.vars = {});
-                    comp.vars[name] = value;
-                }
-                else if (startSegment === "method") {
-                    (_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] = parseEvent(value);
-                }
-                else if (exports.onPrefixRegex.test(name)) {
-                    (_d = comp.events) !== null && _d !== void 0 ? _d : (comp.events = {});
-                    const eventName = name[2].toLowerCase() + name.substring(3);
-                    comp.events[eventName] = parseEvent(value);
-                }
-                else {
-                    (_e = comp.props) !== null && _e !== void 0 ? _e : (comp.props = {});
-                    comp.props[name] = value;
-                }
-                return;
-        }
-    }
-    function 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.kind === syntax_kind_1.SyntaxKind.TextNode) {
-                result = mergeValue(result, getText(child));
-                return;
-            }
-            if (child.kind !== syntax_kind_1.SyntaxKind.ElementNode)
-                return;
-            const childName = getComponentName(child, getText);
-            // --- The only element names we accept are "field" or "item"
-            if (childName !== "field" && childName !== "item") {
-                reportError("T016");
-                return;
-            }
-            if (childName === "field") {
-                if (!nestedElementType) {
-                    // --- First nested element is "field", so we have an object
-                    nestedElementType = childName;
-                    result = {};
-                }
-                else if (nestedElementType !== childName) {
-                    reportError("T017");
-                    return;
-                }
-            }
-            else if (childName === "item") {
-                if (!nestedElementType) {
-                    // --- First nested element is "item", so we have an array
-                    nestedElementType = childName;
-                    result = [];
-                }
-                else if (nestedElementType !== childName) {
-                    reportError("T017");
-                    return;
-                }
-            }
-            // --- Get the field value
-            let valueInfo = collectValue(usesStack, child, childName === "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;
-    }
-    function collectValue(usesStack, element, allowName = true) {
-        const elementName = getComponentName(element, getText);
-        // --- Accept only "name", "value"
-        const childNodes = getChildNodes(element);
-        const nestedComponents = childNodes.filter((c) => c.kind === syntax_kind_1.SyntaxKind.ElementNode && exports.UCRegex.test(getComponentName(c, getText)));
-        const nestedElements = childNodes.filter((c) => c.kind === syntax_kind_1.SyntaxKind.ElementNode && !exports.UCRegex.test(getComponentName(c, getText)));
-        const attributes = getAttributes(element).map(segmentAttr);
-        const attrProps = attributes.filter((attr) => propAttrs.indexOf(attr.name) >= 0);
-        if (attributes.length > attrProps.length) {
-            reportError("T011", elementName);
-            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)) {
-                reportError("T012", elementName);
-                return null;
-            }
-        }
-        else {
-            if (nameAttr) {
-                reportError("T018", elementName);
-                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) {
-            reportError("T019", elementName);
-            return null;
-        }
-        // --- Let's handle a special case, when the value is a component definition
-        if (name && nestedComponents.length >= 1) {
-            if (nestedElements.length > 0) {
-                reportError("T020");
-                return null;
-            }
-            // --- We expect a component definition here!
-            const nestedComps = nestedComponents.map((nc) => transformInnerElement(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: collectObjectOrArray(usesStack, childNodes) };
-    }
-    function collectLoadersElements(usesStack, comp, loaders) {
-        var _a, _b;
-        if (!isComponent(comp)) {
-            reportError("T009", "loaders");
-            return;
-        }
-        const children = getChildNodes(loaders);
-        //todo: this check seems not necesarry
-        if (children.length === 0) {
-            (_a = comp.loaders) !== null && _a !== void 0 ? _a : (comp.loaders = []);
-        }
-        const hasAttribute = (_b = loaders.children) === null || _b === void 0 ? void 0 : _b.some((c) => c.kind === syntax_kind_1.SyntaxKind.AttributeListNode);
-        if (hasAttribute) {
-            reportError("T014", "attributes");
-            return;
-        }
-        children.forEach((loader) => {
-            var _a;
-            // --- Test is not supported
-            if (loader.kind === syntax_kind_1.SyntaxKind.TextNode) {
-                reportError("T010", "loader");
-                return;
-            }
-            // todo: is this needed?
-            // --- Just for the sake of being sure...
-            // if (loader.type !== "Element") return;
-            const loaderDef = transformInnerElement(usesStack, loader);
-            // --- Get the uid value
-            if (!loaderDef.uid) {
-                reportError("T013");
-                return;
-            }
-            // --- Check props that a loader must not have
-            if (loaderDef.vars) {
-                reportError("T014", "vars");
-                return;
-            }
-            if (loaderDef.loaders) {
-                reportError("T014", "loaders");
-                return;
-            }
-            if (loaderDef.uses) {
-                reportError("T014", "uses");
-                return;
-            }
-            // --- Store this loader
-            (_a = comp.loaders) !== null && _a !== void 0 ? _a : (comp.loaders = []);
-            comp.loaders.push(loaderDef);
-        });
-    }
-    function collectElementHelper(usesStack, comp, child, getter, setter, nameValidator) {
-        // --- Compound component do not have a uses
-        var _a;
-        // --- Get the value
-        const valueInfo = 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, mergeValue(getter(name), value));
-        }
-        else {
-            // --- Consider the value to be null; check optional child items
-            const children = getChildNodes(child);
-            const itemValue = collectObjectOrArray(usesStack, children);
-            let updatedValue = getter(name);
-            updatedValue = mergeValue(updatedValue, itemValue);
-            setter(name, updatedValue);
-        }
-    }
-    function collectUsesElements(comp, usesNode) {
-        // --- Compound component do not have a uses
-        if (!isComponent(comp)) {
-            reportError("T009", "uses");
-            return;
-        }
-        const attributes = getAttributes(usesNode).map(segmentAttr);
-        const valueAttr = attributes.find((attr) => attr.name === "value");
-        if (!(valueAttr === null || valueAttr === void 0 ? void 0 : valueAttr.value) || attributes.length !== 1) {
-            reportError("T015", "uses");
-            return;
-        }
-        // --- Extract the value
-        const usesValues = splitUsesValue(valueAttr.value);
-        if (comp.uses) {
-            comp.uses.push(...usesValues);
-        }
-        else {
-            comp.uses = usesValues;
-        }
-    }
-    function segmentAttr(attr) {
-        let key = attr.children[0];
-        const hasNamespace = key.children.length === 3;
-        let namespace;
-        if (hasNamespace) {
-            namespace = getText(key.children[0]);
-        }
-        let unsegmentedName = getText(key.children[key.children.length - 1]);
-        const segments = unsegmentedName.split(".");
-        if (segments.length > 2) {
-            reportError("T007", attr, key);
-        }
-        let name;
-        let startSegment;
-        if (segments.length === 2) {
-            startSegment = segments[0];
-            name = segments[1];
-            if (name.trim() === "") {
-                reportError("T007", attr, name);
-            }
-        }
-        else {
-            //TODO: remove asigning name when name === unsegmentedName. It is there for backwards compat
-            name = unsegmentedName;
-        }
-        const valueText = getText(attr.children[2]);
-        const value = valueText.substring(1, valueText.length - 1);
-        return { namespace, startSegment, name, value, unsegmentedName };
-    }
-    function parseEscapeCharactersInAttrValues(attrs) {
-        for (let attr of attrs) {
-            const attrValue = attr.children[attr.children.length - 1];
-            const escapedText = tryEscapeEntities(getText(attrValue));
-            if (escapedText !== null) {
-                attrValue.text = escapedText;
-            }
-        }
-    }
-    function prepNode(node) {
-        var _a;
-        const childNodes = getChildNodes(node);
-        const tagName = getComponentName(node, getText);
-        const hasComponentName = !(tagName in HelperNode);
-        const shouldUseTextNodeElement = hasComponentName || tagName === "property";
-        const shouldCollapseWhitespace = tagName !== "event" && tagName !== "method";
-        const attrs = getAttributes(node);
-        desugarKeyOnlyAttrs(attrs);
-        parseEscapeCharactersInAttrValues(attrs);
-        parseEscapeCharactersInContent(childNodes);
-        mergeConsecutiveTexts(childNodes, shouldCollapseWhitespace);
-        let shouldUseCData = false;
-        let hasScriptChild = false;
-        for (let i = 0; i < childNodes.length; ++i) {
-            const child = childNodes[i];
-            let newChild;
-            if (child.kind == syntax_kind_1.SyntaxKind.Script) {
-                hasScriptChild = true;
-                continue;
-            }
-            if (child.kind === syntax_kind_1.SyntaxKind.ElementNode) {
-                newChild = prepNode(child);
-                childNodes[i] = newChild;
-                continue;
-            }
-            let textValue = getText(child);
-            if (child.kind === syntax_kind_1.SyntaxKind.StringLiteral) {
-                textValue = textValue.slice(1, -1);
-            }
-            else if (child.kind === syntax_kind_1.SyntaxKind.CData) {
-                shouldUseCData = true;
-            }
-            else if (child.kind === syntax_kind_1.SyntaxKind.TextNode) {
-            }
-            if (shouldUseTextNodeElement) {
-                if (shouldUseCData) {
-                    newChild = createTextNodeCDataElement(textValue);
-                }
-                else {
-                    newChild = createTextNodeElement(textValue);
-                }
-            }
-            else {
-                newChild = {
-                    kind: syntax_kind_1.SyntaxKind.TextNode,
-                    text: textValue,
-                };
-            }
-            childNodes[i] = newChild;
-        }
-        const helperNodes = [];
-        const otherNodes = [];
-        let hasComponentChild = false;
-        for (const child of childNodes) {
-            if (child.kind === syntax_kind_1.SyntaxKind.ElementNode) {
-                let compName = (_a = getComponentName(child, getText)) !== null && _a !== void 0 ? _a : undefined;
-                if (compName in HelperNode) {
-                    helperNodes.push(child);
-                    continue;
-                }
-                hasComponentChild = true;
-            }
-            otherNodes.push(child);
-        }
-        if (hasScriptChild && hasComponentChild) {
-            const fragment = wrapWithFragment(otherNodes);
-            helperNodes.push(fragment);
-            return withNewChildNodes(node, helperNodes);
-        }
-        return node;
-    }
-    function collapseWhitespace(childNodes) {
-        for (let i = 0; i < childNodes.length; ++i) {
-            if (childNodes[i].kind === syntax_kind_1.SyntaxKind.StringLiteral ||
-                childNodes[i].kind === syntax_kind_1.SyntaxKind.TextNode) {
-                //the union is the same as \s , but took \u00a0 (non breaking space) out
-                //source https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions/Cheatsheet
-                const allSubsequentWsExceptNonBreakingSpace = /[\f\n\r\t\v\u0020\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]+/g;
-                childNodes[i].text = getText(childNodes[i]).replace(allSubsequentWsExceptNonBreakingSpace, " ");
-            }
-        }
-    }
-    function stripCDataWrapper(childNodes) {
-        for (let i = 0; i < childNodes.length; ++i) {
-            if (childNodes[i].kind === syntax_kind_1.SyntaxKind.CData) {
-                childNodes[i].text = getText(childNodes[i]).slice(CDATA_PREFIX_LEN, -CDATA_POSTFIX_LEN);
-            }
-        }
-    }
-    function parseEscapeCharactersInContent(childNodes) {
-        for (let node of childNodes) {
-            if (node.kind === syntax_kind_1.SyntaxKind.StringLiteral || node.kind === syntax_kind_1.SyntaxKind.TextNode) {
-                const escapedText = tryEscapeEntities(getText(node));
-                if (escapedText !== null) {
-                    node.text = escapedText;
-                }
-            }
-        }
-    }
-    function tryEscapeEntities(text) {
-        let newText = "";
-        let startOfSubstr = 0;
-        for (let i = 0; i < text.length; ++i) {
-            if (text.charCodeAt(i) === CharacterCodes_1.CharacterCodes.ampersand) {
-                switch (text.charCodeAt(i + 1)) {
-                    //&a
-                    case CharacterCodes_1.CharacterCodes.a:
-                        switch (text.charCodeAt(i + 2)) {
-                            //am
-                            case CharacterCodes_1.CharacterCodes.m:
-                                //amp;
-                                if (text.charCodeAt(i + 3) === CharacterCodes_1.CharacterCodes.p &&
-                                    text.charCodeAt(i + 4) === CharacterCodes_1.CharacterCodes.semicolon) {
-                                    newText = newText + text.substring(startOfSubstr, i) + "&";
-                                    i += 4;
-                                    startOfSubstr = i + 1;
-                                }
-                                break;
-                            //ap
-                            case CharacterCodes_1.CharacterCodes.p:
-                                //apos;
-                                if (text.charCodeAt(i + 3) === CharacterCodes_1.CharacterCodes.o &&
-                                    text.charCodeAt(i + 4) === CharacterCodes_1.CharacterCodes.s &&
-                                    text.charCodeAt(i + 5) === CharacterCodes_1.CharacterCodes.semicolon) {
-                                    newText = newText + text.substring(startOfSubstr, i) + "'";
-                                    i += 5;
-                                    startOfSubstr = i + 1;
-                                }
-                                break;
-                        }
-                        break;
-                    //&g
-                    case CharacterCodes_1.CharacterCodes.g:
-                        //\gt;
-                        if (text.charCodeAt(i + 2) === CharacterCodes_1.CharacterCodes.t &&
-                            text.charCodeAt(i + 3) === CharacterCodes_1.CharacterCodes.semicolon) {
-                            newText = newText + text.substring(startOfSubstr, i) + ">";
-                            i += 3;
-                            startOfSubstr = i + 1;
-                        }
-                        break;
-                    //&l
-                    case CharacterCodes_1.CharacterCodes.l:
-                        //&lt;
-                        if (text.charCodeAt(i + 2) === CharacterCodes_1.CharacterCodes.t &&
-                            text.charCodeAt(i + 3) === CharacterCodes_1.CharacterCodes.semicolon) {
-                            newText = newText + text.substring(startOfSubstr, i) + "<";
-                            i += 3;
-                            startOfSubstr = i + 1;
-                        }
-                        break;
-                    //&q
-                    case CharacterCodes_1.CharacterCodes.q:
-                        //&quot;
-                        if (text.charCodeAt(i + 2) === CharacterCodes_1.CharacterCodes.u &&
-                            text.charCodeAt(i + 3) === CharacterCodes_1.CharacterCodes.o &&
-                            text.charCodeAt(i + 4) === CharacterCodes_1.CharacterCodes.t &&
-                            text.charCodeAt(i + 5) === CharacterCodes_1.CharacterCodes.semicolon) {
-                            newText = newText + text.substring(startOfSubstr, i) + '"';
-                            i += 5;
-                            startOfSubstr = i + 1;
-                        }
-                        break;
-                    //&n
-                    case CharacterCodes_1.CharacterCodes.n:
-                        //&nbsp;
-                        if (text.charCodeAt(i + 2) === CharacterCodes_1.CharacterCodes.b &&
-                            text.charCodeAt(i + 3) === CharacterCodes_1.CharacterCodes.s &&
-                            text.charCodeAt(i + 4) === CharacterCodes_1.CharacterCodes.p &&
-                            text.charCodeAt(i + 5) === CharacterCodes_1.CharacterCodes.semicolon) {
-                            newText = newText + text.substring(startOfSubstr, i) + "\xa0";
-                            i += 5;
-                            startOfSubstr = i + 1;
-                        }
-                        break;
-                }
-            }
-        }
-        if (startOfSubstr === 0) {
-            return null;
-        }
-        newText += text.substring(startOfSubstr);
-        return newText;
-    }
-    function mergeConsecutiveTexts(childNodes, shouldCollapseWs) {
-        if (shouldCollapseWs) {
-            collapseWhitespace(childNodes);
-        }
-        stripCDataWrapper(childNodes);
-        for (let i = childNodes.length - 1; i > 0; --i) {
-            const node = childNodes[i - 1];
-            const nextNode = childNodes[i];
-            if (node.kind === syntax_kind_1.SyntaxKind.StringLiteral && nextNode.kind === syntax_kind_1.SyntaxKind.CData) {
-                childNodes[i - 1] = {
-                    kind: syntax_kind_1.SyntaxKind.CData,
-                    text: getText(node).slice(1, -1) + getText(nextNode),
-                };
-                childNodes.pop();
-            }
-            else if (node.kind === syntax_kind_1.SyntaxKind.CData && nextNode.kind === syntax_kind_1.SyntaxKind.StringLiteral) {
-                childNodes[i - 1] = {
-                    kind: syntax_kind_1.SyntaxKind.CData,
-                    text: getText(node) + getText(nextNode).slice(1, -1),
-                };
-                childNodes.pop();
-            }
-            else if (node.kind === syntax_kind_1.SyntaxKind.CData && nextNode.kind === syntax_kind_1.SyntaxKind.TextNode) {
-                childNodes[i - 1] = {
-                    kind: syntax_kind_1.SyntaxKind.CData,
-                    text: getText(node) + getText(nextNode),
-                };
-                childNodes.pop();
-            }
-            else if (node.kind === syntax_kind_1.SyntaxKind.CData && nextNode.kind === syntax_kind_1.SyntaxKind.CData) {
-                childNodes[i - 1] = {
-                    kind: syntax_kind_1.SyntaxKind.CData,
-                    text: getText(node) + getText(nextNode),
-                };
-                childNodes.pop();
-            }
-            else if (node.kind === syntax_kind_1.SyntaxKind.TextNode && nextNode.kind === syntax_kind_1.SyntaxKind.TextNode) {
-                if (getText(node).endsWith(" ") && getText(nextNode).startsWith(" ")) {
-                    node.text = getText(node).trimEnd();
-                }
-                childNodes[i - 1] = {
-                    kind: syntax_kind_1.SyntaxKind.TextNode,
-                    text: getText(node) + getText(nextNode),
-                };
-                childNodes.pop();
-            }
-            else if (node.kind === syntax_kind_1.SyntaxKind.TextNode && nextNode.kind === syntax_kind_1.SyntaxKind.CData) {
-                childNodes[i - 1] = {
-                    kind: syntax_kind_1.SyntaxKind.CData,
-                    text: getText(node) + getText(nextNode),
-                };
-                childNodes.pop();
-            }
-        }
-    }
-    function parseEvent(value) {
-        if (typeof value !== "string") {
-            // --- It must be a component definition in the event code
-            return value;
-        }
-        // --- Parse the event code
-        const parser = new Parser_1.Parser(value);
-        try {
-            const statements = parser.parseStatements();
-            return {
-                __PARSED: true,
-                statements,
-                parseId: ++lastParseId,
-                // TODO: retrieve the event source code only in dev mode
-                source: value,
-            };
-        }
-        catch (_a) {
-            if (parser.errors.length > 0) {
-                const errMsg = parser.errors[0];
-                throw new ParserError_1.ParserError(`${errMsg.text} [${errMsg.line}: ${errMsg.column}]`, errMsg.code);
-            }
-        }
-    }
-}
-function createTextNodeCDataElement(textValue) {
-    return {
-        kind: syntax_kind_1.SyntaxKind.ElementNode,
-        children: [
-            { kind: syntax_kind_1.SyntaxKind.OpenNodeStart },
-            {
-                kind: syntax_kind_1.SyntaxKind.TagNameNode,
-                children: [{ kind: syntax_kind_1.SyntaxKind.Identifier, text: "TextNodeCData" }],
-            },
-            {
-                kind: syntax_kind_1.SyntaxKind.AttributeListNode,
-                children: [
-                    {
-                        kind: syntax_kind_1.SyntaxKind.AttributeNode,
-                        children: [
-                            {
-                                kind: syntax_kind_1.SyntaxKind.AttributeKeyNode,
-                                children: [{ kind: syntax_kind_1.SyntaxKind.Identifier, text: "value" }],
-                            },
-                            { kind: syntax_kind_1.SyntaxKind.Equal },
-                            { kind: syntax_kind_1.SyntaxKind.Identifier, text: `"${textValue}"` },
-                        ],
-                    },
-                ],
-            },
-            { kind: syntax_kind_1.SyntaxKind.NodeClose },
-        ],
-    };
-}
-function createTextNodeElement(textValue) {
-    return {
-        kind: syntax_kind_1.SyntaxKind.ElementNode,
-        children: [
-            { kind: syntax_kind_1.SyntaxKind.OpenNodeStart },
-            {
-                kind: syntax_kind_1.SyntaxKind.TagNameNode,
-                children: [{ kind: syntax_kind_1.SyntaxKind.Identifier, text: "TextNode" }],
-            },
-            {
-                kind: syntax_kind_1.SyntaxKind.AttributeListNode,
-                children: [
-                    {
-                        kind: syntax_kind_1.SyntaxKind.AttributeNode,
-                        children: [
-                            {
-                                kind: syntax_kind_1.SyntaxKind.AttributeKeyNode,
-                                children: [{ kind: syntax_kind_1.SyntaxKind.Identifier, text: "value" }],
-                            },
-                            { kind: syntax_kind_1.SyntaxKind.Equal },
-                            { kind: syntax_kind_1.SyntaxKind.Identifier, text: `"${textValue}"` },
-                        ],
-                    },
-                ],
-            },
-            { kind: syntax_kind_1.SyntaxKind.NodeClose },
-        ],
-    };
-}
-/**
- * Reports the specified error
- * @param errorCode Error code
- * @param options Error message options
- */
-function reportError(errorCode, ...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())));
-    }
-    throw new ParserError_1.ParserError(errorText, errorCode);
-    function replace(input, placeholder, replacement) {
-        do {
-            input = input.replace(placeholder, replacement);
-        } while (input.includes(placeholder));
-        return input;
-    }
-}
-function isComponent(obj) {
-    return obj.type;
-}
-function 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;
-    }
-}
-function wrapWithFragment(wrappedChildren) {
-    const nameNode = {
-        kind: syntax_kind_1.SyntaxKind.TagNameNode,
-        children: [{ kind: syntax_kind_1.SyntaxKind.Identifier, text: "Fragment" }],
-    };
-    return {
-        kind: syntax_kind_1.SyntaxKind.ElementNode,
-        start: wrappedChildren[0].start,
-        pos: wrappedChildren[0].pos,
-        end: wrappedChildren[wrappedChildren.length - 1].end,
-        children: [
-            { kind: syntax_kind_1.SyntaxKind.OpenNodeStart },
-            nameNode,
-            { kind: syntax_kind_1.SyntaxKind.NodeEnd },
-            { kind: syntax_kind_1.SyntaxKind.ContentListNode, children: wrappedChildren },
-            { kind: syntax_kind_1.SyntaxKind.CloseNodeStart },
-            nameNode,
-            { kind: syntax_kind_1.SyntaxKind.NodeEnd },
-        ],
-    };
-}
-function getAttributes(node) {
-    var _a, _b, _c;
-    return (_c = (_b = (_a = node.children) === null || _a === void 0 ? void 0 : _a.find((c) => c.kind === syntax_kind_1.SyntaxKind.AttributeListNode)) === null || _b === void 0 ? void 0 : _b.children) !== null && _c !== void 0 ? _c : [];
-}
-function getChildNodes(node) {
-    var _a, _b, _c;
-    return (_c = (_b = (_a = node.children) === null || _a === void 0 ? void 0 : _a.find((c) => c.kind === syntax_kind_1.SyntaxKind.ContentListNode)) === null || _b === void 0 ? void 0 : _b.children) !== null && _c !== void 0 ? _c : [];
-}
-function withNewChildNodes(node, newChildren) {
-    var _a, _b, _c, _d, _e;
-    const childrenListIdx = (_a = node.children) === null || _a === void 0 ? void 0 : _a.findIndex((c) => c.kind === syntax_kind_1.SyntaxKind.ContentListNode);
-    if (childrenListIdx === undefined || childrenListIdx === -1) {
-        return node;
-    }
-    const contentListChild = node.children[childrenListIdx];
-    return new syntax_node_1.Node(node.kind, (_b = node.pos) !== null && _b !== void 0 ? _b : 0, (_c = node.end) !== null && _c !== void 0 ? _c : 0, node.triviaBefore, [
-        ...node.children.slice(0, childrenListIdx),
-        new syntax_node_1.Node(contentListChild.kind, (_d = contentListChild.pos) !== null && _d !== void 0 ? _d : 0, (_e = contentListChild.end) !== null && _e !== void 0 ? _e : 0, undefined, newChildren),
-        ...node.children.slice(childrenListIdx),
-    ]);
-}
-function desugarKeyOnlyAttrs(attrs) {
-    var _a;
-    for (let attr of attrs) {
-        if (((_a = attr.children) === null || _a === void 0 ? void 0 : _a.length) === 1) {
-            const eq = {
-                kind: syntax_kind_1.SyntaxKind.Equal,
-            };
-            const value = {
-                kind: syntax_kind_1.SyntaxKind.StringLiteral,
-                text: '"true"',
-            };
-            attr.children.push(eq, value);
-        }
-    }
-}
-function addToNamespaces(namespaceStack, comp, nsKey, value) {
-    let nsCommaSeparated = value.split(":");
-    if (nsCommaSeparated.length > 2) {
-        return reportError("T028", value, "Namespace cannot contain multiple ':' (colon).");
-    }
-    let nsValue = value;
-    if (nsCommaSeparated.length === 2) {
-        if (nsCommaSeparated[0] != COMPONENT_NAMESPACE_SCHEME) {
-            return reportError("T029", value, COMPONENT_NAMESPACE_SCHEME);
-        }
-        nsValue = nsCommaSeparated[1];
-    }
-    if (nsValue.includes("#")) {
-        return reportError("T028", nsValue, "Namespace cannot contain character '#'.");
-    }
-    switch (nsValue) {
-        case COMPONENT_NAMESPACE_SCHEME:
-            nsValue = nsKey;
-            break;
-        case APP_NS_KEY:
-            nsValue = APP_NS_VALUE;
-            break;
-        case CORE_NS_KEY:
-            nsValue = exports.CORE_NAMESPACE_VALUE;
-            break;
-    }
-    const compNamespaces = namespaceStack[namespaceStack.length - 1];
-    if (compNamespaces.has(nsKey)) {
-        return reportError("T025", nsKey);
-    }
-    compNamespaces.set(nsKey, nsValue);
-}
-function getTopLvlElement(node, getText) {
-    // --- Check that the nodes contains exactly only a single component root element before the EoF token
-    if (node.children.length !== 2) {
-        reportError("T001");
-    }
-    // --- Ensure it's a component
-    const element = node.children[0];
-    if (element.kind !== syntax_kind_1.SyntaxKind.ElementNode) {
-        reportError("T001");
-    }
-    return element;
-}
-function getComponentName(node, getText) {
-    const nameTokens = node.children.find((c) => c.kind === syntax_kind_1.SyntaxKind.TagNameNode).children;
-    const name = getText(nameTokens.at(-1));
-    return name;
-}
-function getNamespaceResolvedComponentName(node, getText, namespaceStack) {
-    const nameTokens = node.children.find((c) => c.kind === syntax_kind_1.SyntaxKind.TagNameNode).children;
-    const name = getText(nameTokens.at(-1));
-    if (nameTokens.length === 1) {
-        return name;
-    }
-    const namespace = getText(nameTokens[0]);
-    if (namespaceStack.length === 0) {
-        reportError("T026");
-    }
-    let resolvedNamespace = undefined;
-    for (let i = namespaceStack.length - 1; i >= 0; --i) {
-        resolvedNamespace = namespaceStack[i].get(namespace);
-        if (resolvedNamespace !== undefined) {
-            break;
-        }
-    }
-    if (resolvedNamespace === undefined) {
-        reportError("T027", namespace);
-    }
-    return resolvedNamespace + "." + name;
-}
-/**
- * @param name - The name of the event in camelCase, with "on" prefix.
- */
-function stripOnPrefix(name) {
-    return name[2].toLowerCase() + name.substring(3);
-}
-function splitUsesValue(value) {
-    return value.split(",").map((v) => v.trim());
-}