xmlui 0.4.0

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

@@ -0,0 +1,922 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onPrefixRegex = exports.UCRegex = exports.COMPOUND_COMP_ID = void 0;
+exports.nodeToComponentDef = nodeToComponentDef;
+const syntax_kind_1 = require("./syntax-kind");
+const ParserError_1 = require("../ueml/ParserError");
+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");
+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;
+function nodeToComponentDef(node, originalGetText, moduleResolver = () => "") {
+    const getText = (node) => {
+        var _a;
+        return (_a = node.text) !== null && _a !== void 0 ? _a : originalGetText(node);
+    };
+    // --- Check that the nodes contains exactly only a single component root element before the EoF token
+    if (node.children.length !== 2) {
+        reportError("T001");
+        return null;
+    }
+    // --- Ensure it's a component
+    const element = node.children[0];
+    if (element.kind !== syntax_kind_1.SyntaxKind.ElementNode) {
+        reportError("T001");
+        return null;
+    }
+    const preppedElement = prepNode(element);
+    const name = getTagName(element);
+    if (!exports.UCRegex.test(name)) {
+        reportError("T002");
+        return null;
+    }
+    const usesStack = [];
+    return transformSingleElement(usesStack, preppedElement);
+    function transformSingleElement(usesStack, node) {
+        const name = getTagName(node);
+        const attrs = getAttributes(node).map(segmentAttr);
+        let component;
+        if (name === exports.COMPOUND_COMP_ID) {
+            // --- Validate component name
+            const compoundName = attrs.find((attr) => attr.name === "name");
+            if (!compoundName) {
+                reportError("T003");
+                return null;
+            }
+            if (!exports.UCRegex.test(compoundName.value)) {
+                reportError("T004");
+                return null;
+            }
+            // --- Get "api" attributes
+            let api;
+            const apiAttrs = attrs.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 = attrs.filter((attr) => attr.startSegment === "var");
+            if (varsAttrs.length > 0) {
+                vars = {};
+                varsAttrs.forEach((attr) => {
+                    vars[attr.name] = attr.value;
+                });
+            }
+            const children = getChildNodes(node);
+            // --- Check for nested component
+            const nestedCompound = children.find((child) => child.kind === syntax_kind_1.SyntaxKind.ElementNode && getTagName(child) === exports.COMPOUND_COMP_ID);
+            if (nestedCompound) {
+                reportError("T006");
+                return null;
+            }
+            // --- Get the single component definition
+            const nestedComponents = children.filter((child) => child.kind === syntax_kind_1.SyntaxKind.ElementNode && exports.UCRegex.test(getTagName(child)));
+            if (nestedComponents.length === 0) {
+                nestedComponents.push(createTextNodeElement(""));
+            }
+            const childrenToCollect = [];
+            const nestedVars = [];
+            for (let child of children) {
+                if (child.kind === syntax_kind_1.SyntaxKind.ElementNode) {
+                    const childName = getTagName(child);
+                    if (childName === "var") {
+                        nestedVars.push(child);
+                    }
+                    else if (!exports.UCRegex.test(childName)) {
+                        childrenToCollect.push(child);
+                    }
+                }
+            }
+            // --- Should we use a Fragment?
+            if (nestedComponents.length > 1 || nestedVars.length > 0) {
+                // --- Wrap the children in a Fragment
+                const fragmentElement = wrapWithFragment([...nestedVars, ...nestedComponents]);
+                const nestedFragment = 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 = 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 = withNewChildNodes(node, childrenToCollect);
+            collectTraits(usesStack, component, nodeClone);
+            return component;
+        }
+        // --- Not a reusable component
+        if (!exports.UCRegex.test(name)) {
+            reportError("T002");
+            return null;
+        }
+        component = {
+            type: name,
+        };
+        // --- Done
+        collectTraits(usesStack, component, node);
+        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);
+        // --- 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;
+            }
+            const childName = getTagName(child);
+            if (isCompound && child.kind === syntax_kind_1.SyntaxKind.ElementNode && exports.UCRegex.test(childName)) {
+                // --- 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.kind === syntax_kind_1.SyntaxKind.TextNode && !isCompound) {
+                comp.children = mergeValue(comp.children, getText(child));
+            }
+            // --- It should not happen, but just for being safe...
+            // todo:
+            // if (child.kind !== SyntaxKind.node) throw new Error("should not happen");
+            // --- Element name starts with an uppercase letter
+            if (exports.UCRegex.test(childName) && !isCompound) {
+                // --- This must be a child component
+                const childComponent = 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 (childName) {
+                case "prop":
+                    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] = value;
+                    }, (name) => {
+                        if (exports.onPrefixRegex.test(name)) {
+                            reportError("T008", name);
+                        }
+                    });
+                    return;
+                case "var":
+                    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 "api":
+                    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;
+            }
+        });
+        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, 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 = (_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 { startSegment, name, value } = segmentAttr(attr);
+        const isCompound = !isComponent(comp);
+        // --- Handle single-word attributes
+        if (isCompound) {
+            if (startSegment && startSegment !== "api" && startSegment !== "var") {
+                reportError("T021");
+                return;
+            }
+            if (name === "name" && !startSegment) {
+                // --- We already processed name
+                return;
+            }
+            // --- Compound components do not have any other attributable props
+            if (!startSegment && name) {
+                reportError("T021", name);
+            }
+            return;
+        }
+        // --- Do not allow segmented attribute names
+        if (name.indexOf(".") >= 0) {
+            reportError("T007", 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 (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] = 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 = getTagName(child);
+            // --- 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 = getTagName(element);
+        // --- Accept only "name", "value"
+        const childNodes = getChildNodes(element);
+        const nestedComponents = childNodes.filter((c) => c.kind === syntax_kind_1.SyntaxKind.ElementNode && exports.UCRegex.test(getTagName(c)));
+        const nestedElements = childNodes.filter((c) => c.kind === syntax_kind_1.SyntaxKind.ElementNode && !exports.UCRegex.test(getTagName(c)));
+        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) => 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: 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 = transformSingleElement(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, uses) {
+        var _a;
+        // --- Compound component do not have a uses
+        if (!isComponent(comp)) {
+            reportError("T009", "uses");
+            return;
+        }
+        const attributes = getAttributes(uses).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
+        (_a = comp.uses) !== null && _a !== void 0 ? _a : (comp.uses = valueAttr.value.split(",").map((v) => v.trim()));
+    }
+    function getTagName(node) {
+        const nameTokens = node.children.find((c) => c.kind === syntax_kind_1.SyntaxKind.TagNameNode).children;
+        const name = nameTokens[nameTokens.length - 1];
+        return getText(name);
+    }
+    function segmentAttr(attr) {
+        let key = getText(attr.children[0]);
+        const segments = key.split(".");
+        if (segments.length > 2) {
+            reportError("T007", attr, key);
+        }
+        let startSegment;
+        let name = key;
+        if (segments.length === 2) {
+            startSegment = segments[0];
+            name = segments[1];
+            if (name.trim() === "") {
+                reportError("T007", attr, name);
+            }
+        }
+        const valueText = getText(attr.children[2]);
+        const value = valueText.substring(1, valueText.length - 1);
+        return { startSegment, name, value };
+    }
+    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) {
+        const childNodes = getChildNodes(node);
+        const tagName = getTagName(node);
+        const hasComponentName = exports.UCRegex.test(tagName);
+        const shouldUseTextNodeElement = hasComponentName || tagName === "prop";
+        const shouldCollapseWhitespace = tagName !== "event" && tagName !== "api";
+        parseEscapeCharactersInAttrValues(getAttributes(node));
+        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 = childNodes.filter((c) => c.kind === syntax_kind_1.SyntaxKind.ElementNode && !exports.UCRegex.test(getTagName(c)));
+        const otherNodes = childNodes.filter((c) => c.kind !== syntax_kind_1.SyntaxKind.ElementNode || (c.kind === syntax_kind_1.SyntaxKind.ElementNode && exports.UCRegex.test(getTagName(c))));
+        const hasComponentChild = otherNodes.some((c) => c.kind === syntax_kind_1.SyntaxKind.ElementNode && exports.UCRegex.test(getTagName(c)));
+        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 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.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.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,
+        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;
+    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;
+    }
+    return Object.assign(Object.assign({}, node), { children: [
+            ...node.children.slice(0, childrenListIdx),
+            Object.assign(Object.assign({}, node.children[childrenListIdx]), { children: newChildren }),
+            ...node.children.slice(childrenListIdx),
+        ] });
+}