xmlui 0.9.21 → 0.9.25

package/dist/scripts/src/components/Markdown/Markdown.js

@@ -10,12 +10,19 @@ const ComponentDefs_1 = require("../../abstractions/ComponentDefs");
 const renderers_1 = require("../../components-core/renderers");
 const themeVars_1 = require("../../components-core/theming/themeVars");
 const MarkdownNative_1 = require("./MarkdownNative");
+const react_1 = require("react");
+const parse_binding_expr_1 = require("./parse-binding-expr");
+const utils_1 = require("./utils");
 const COMP = "Markdown";
 exports.MarkdownMd = (0, ComponentDefs_1.createMetadata)({
     description: `\`${COMP}\` displays plain text styled using markdown syntax.`,
     themeVars: (0, themeVars_1.parseScssVar)(Markdown_module_scss_1.default.themeVars),
     props: {
         content: (0, ComponentDefs_1.d)("This property sets the markdown content to display."),
+        codeHighlighter: {
+            description: "This property sets the code highlighter to use.",
+            isInternal: true,
+        },
         removeIndents: {
             description: "This boolean property specifies whether leading indents should be " +
                 "removed from the markdown content. If set to `true`, the shortest " +
@@ -26,26 +33,33 @@ exports.MarkdownMd = (0, ComponentDefs_1.createMetadata)({
         },
     },
     defaultThemeVars: {
-        "backgroundColor-Admonition": "$color-warn-300",
-        "borderRadius-Admonition": "$space-4",
-        "iconSize-Admonition": "$space-6",
-        "padding-Admonition": "$space-4",
-        "marginBottom-Admonition": "$space-4",
-        "marginLeft-Admonition-content": "$space-2",
-        "backgroundColor-Blockquote": "$color-warn-200",
+        "backgroundColor-Admonition": "$color-primary-100",
+        "borderRadius-Admonition": "$space-2",
+        "border-Admonition": "1px solid $color-primary-300",
+        "iconSize-Admonition": "$space-5",
+        "paddingLeft-Admonition": "$space-2",
+        "paddingRight-Admonition": "$space-6",
+        "paddingTop-Admonition": "$space-3",
+        "paddingBottom-Admonition": "$space-2",
+        "marginLeft-Admonition-content": "$space-1_5",
+        "marginTop-Admonition": "$space-7",
+        "marginBottom-Admonition": "$space-7",
+        "marginTop-Blockquote": "$space-7",
+        "marginBottom-Blockquote": "$space-7",
+        "paddingHorizontal-Blockquote": "$space-6",
+        "paddingTop-Blockquote": "$space-3",
+        "paddingBottom-Blockquote": "$space-2_5",
+        "backgroundColor-Blockquote": "$color-surface-100",
         "accentWidth-Blockquote": "3px",
         "accentColor-Blockquote": "$color-surface-500",
-        "padding-Blockquote": "$space-2",
-        "marginBottom-Blockquote": "$space-4",
-        "marginBottom-Text-codefence": "$space-2",
-        "marginBottom-Text-markdown": "$space-2",
-        "marginTop-HtmlLi": "$space-2",
-        "marginBottom-HtmlLi": "$space-2",
+        "marginTop-HtmlLi": "$space-2_5",
+        "marginBottom-HtmlLi": "$space-2_5",
         light: {
         // --- No light-specific theme vars
         },
         dark: {
-        // --- No dark-specific theme vars
+            "backgroundColor-Blockquote": "$color-surface-50",
+            "backgroundColor-Admonition": "$color-primary-200",
         },
     },
 });
@@ -56,7 +70,7 @@ exports.markdownComponentRenderer = (0, renderers_1.createComponentRenderer)(COM
     if (!renderedChildren) {
         renderedChildren = extractValue.asString(node.props.content);
     }
-    // 2. "data" property fallback)
+    // 2. "data" property fallback
     if (!renderedChildren) {
         renderedChildren = extractValue.asString(node.props.data);
     }
@@ -69,7 +83,29 @@ exports.markdownComponentRenderer = (0, renderers_1.createComponentRenderer)(COM
             }
         });
     }
-    return ((0, jsx_runtime_1.jsx)(MarkdownNative_1.Markdown, { style: layoutCss, removeIndents: extractValue.asOptionalBoolean(node.props.removeIndents, true), extractValue: extractValue, children: renderedChildren }));
+    return ((0, jsx_runtime_1.jsx)(TransformedMarkdown, { style: layoutCss, removeIndents: extractValue.asOptionalBoolean(node.props.removeIndents, true), codeHighlighter: extractValue(node.props.codeHighlighter), extractValue: extractValue, children: renderedChildren }));
 });
+const TransformedMarkdown = ({ children, removeIndents, style, extractValue, codeHighlighter, }) => {
+    const markdownContent = (0, react_1.useMemo)(() => {
+        if (typeof children !== "string") {
+            return null;
+        }
+        // --- Resolve binding expression values
+        // --- Resolve xmlui playground definitions
+        let resolvedMd = children;
+        while (true) {
+            const nextPlayground = (0, utils_1.observePlaygroundPattern)(resolvedMd);
+            if (!nextPlayground)
+                break;
+            resolvedMd =
+                resolvedMd.slice(0, nextPlayground[0]) +
+                    (0, utils_1.convertPlaygroundPatternToMarkdown)(nextPlayground[2]) +
+                    resolvedMd.slice(nextPlayground[1]);
+        }
+        resolvedMd = (0, parse_binding_expr_1.parseBindingExpression)(resolvedMd, extractValue);
+        return resolvedMd;
+    }, [children, extractValue]);
+    return ((0, jsx_runtime_1.jsx)(MarkdownNative_1.Markdown, { removeIndents: removeIndents, codeHighlighter: codeHighlighter, style: style, children: markdownContent }));
+};
 var MarkdownNative_2 = require("./MarkdownNative");
 Object.defineProperty(exports, "Markdown", { enumerable: true, get: function () { return MarkdownNative_2.Markdown; } });

package/dist/scripts/src/components/Markdown/MarkdownNative.js

@@ -18,23 +18,38 @@ exports.Markdown = void 0;
 const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = require("react");
 const react_2 = __importDefault(require("react"));
-const react_markdown_1 = __importDefault(require("react-markdown"));
+const react_markdown_1 = require("react-markdown");
 const remark_gfm_1 = __importDefault(require("remark-gfm"));
 const rehype_raw_1 = __importDefault(require("rehype-raw"));
-const unist_util_visit_1 = require("unist-util-visit");
 const Markdown_module_scss_1 = __importDefault(require("./Markdown.module.scss"));
 const HtmlTags_module_scss_1 = __importDefault(require("../HtmlTags/HtmlTags.module.scss"));
 const HeadingNative_1 = require("../Heading/HeadingNative");
 const TextNative_1 = require("../Text/TextNative");
 const LinkNative_1 = require("../Link/LinkNative");
 const Toggle_1 = require("../Toggle/Toggle");
-const ScriptingSourceTree_1 = require("../../abstractions/scripting/ScriptingSourceTree");
-exports.Markdown = (0, react_1.memo)(function Markdown({ extractValue, removeIndents = true, children, style, }) {
+const NestedAppNative_1 = require("../NestedApp/NestedAppNative");
+const highlight_code_1 = require("./highlight-code");
+const ThemeContext_1 = require("../../components-core/theming/ThemeContext");
+const CodeBlockNative_1 = require("../CodeBlock/CodeBlockNative");
+function PreTagComponent({ id, children, codeHighlighter }) {
+    // TEMP: After ironing out theming for syntax highlighting, this should be removed
+    const { activeThemeTone } = (0, ThemeContext_1.useTheme)();
+    const defaultCodefence = ((0, jsx_runtime_1.jsx)(CodeBlockNative_1.CodeBlock, { children: (0, jsx_runtime_1.jsx)(TextNative_1.Text, { uid: id, variant: "codefence", children: children }) }));
+    if (!codeHighlighter) {
+        return defaultCodefence;
+    }
+    const highlighterResult = (0, highlight_code_1.parseMetaAndHighlightCode)(children, codeHighlighter, activeThemeTone);
+    if (!highlighterResult) {
+        return defaultCodefence;
+    }
+    return ((0, jsx_runtime_1.jsx)(CodeBlockNative_1.CodeBlock, { meta: highlighterResult.meta, textToCopy: highlighterResult.codeStr, children: (0, jsx_runtime_1.jsx)(TextNative_1.Text, { uid: id, variant: "codefence", syntaxHighlightClasses: highlighterResult.classNames, dangerouslySetInnerHTML: { __html: highlighterResult.cleanedHtmlStr } }) }));
+}
+exports.Markdown = (0, react_1.memo)(function Markdown({ removeIndents = true, children, style, codeHighlighter, }) {
     if (typeof children !== "string") {
         return null;
     }
     children = removeIndents ? removeTextIndents(children) : children;
-    return ((0, jsx_runtime_1.jsx)("div", { className: Markdown_module_scss_1.default.markdownContent, style: Object.assign({}, style), children: (0, jsx_runtime_1.jsx)(react_markdown_1.default, { remarkPlugins: [remark_gfm_1.default, [bindingExpression, { extractValue }]], rehypePlugins: [rehype_raw_1.default], components: {
+    return ((0, jsx_runtime_1.jsx)("div", { className: Markdown_module_scss_1.default.markdownContent, style: Object.assign({}, style), children: (0, jsx_runtime_1.jsx)(react_markdown_1.MarkdownHooks, { remarkPlugins: [remark_gfm_1.default, CodeBlockNative_1.markdownCodeBlockParser], rehypePlugins: [rehype_raw_1.default], components: {
                 details(_a) {
                     var { children, node } = _a, props = __rest(_a, ["children", "node"]);
                     return ((0, jsx_runtime_1.jsx)("details", Object.assign({ className: HtmlTags_module_scss_1.default.htmlDetails }, props, { children: children })));
@@ -48,7 +63,7 @@ exports.Markdown = (0, react_1.memo)(function Markdown({ extractValue, removeInd
                     const src = props === null || props === void 0 ? void 0 : props.src;
                     const popOut = props === null || props === void 0 ? void 0 : props["data-popout"];
                     if (popOut) {
-                        return ((0, jsx_runtime_1.jsx)("a", { href: src, target: "_blank", children: (0, jsx_runtime_1.jsx)("img", Object.assign({ className: HtmlTags_module_scss_1.default.htmlImage }, props, { children: children })) }));
+                        return ((0, jsx_runtime_1.jsx)("a", { href: src, target: "_blank", rel: "noreferrer", children: (0, jsx_runtime_1.jsx)("img", Object.assign({ className: HtmlTags_module_scss_1.default.htmlImage }, props, { children: children })) }));
                     }
                     else {
                         return ((0, jsx_runtime_1.jsx)("img", Object.assign({ className: HtmlTags_module_scss_1.default.htmlImage }, props, { children: children })));
@@ -79,7 +94,7 @@ exports.Markdown = (0, react_1.memo)(function Markdown({ extractValue, removeInd
                     return ((0, jsx_runtime_1.jsx)(TextNative_1.Text, { uid: id, variant: "code", children: children }));
                 },
                 pre({ id, children }) {
-                    return ((0, jsx_runtime_1.jsx)(TextNative_1.Text, { uid: id, variant: "codefence", children: children }));
+                    return (0, jsx_runtime_1.jsx)(PreTagComponent, { id: id, codeHighlighter: codeHighlighter, children: children });
                 },
                 strong({ id, children }) {
                     return ((0, jsx_runtime_1.jsx)(TextNative_1.Text, { uid: id, variant: "strong", children: children }));
@@ -110,8 +125,7 @@ exports.Markdown = (0, react_1.memo)(function Markdown({ extractValue, removeInd
                 },
                 a(_a) {
                     var { children, href } = _a, props = __rest(_a, ["children", "href"]);
-                    const allowedProps = ["style", "disabled", "active", "icon", "onClick"];
-                    return ((0, jsx_runtime_1.jsx)(LinkNative_1.LocalLink, Object.assign({ to: href }, allowedProps, { children: children })));
+                    return ((0, jsx_runtime_1.jsx)(LinkNative_1.LocalLink, Object.assign({ to: href }, props, { children: children })));
                 },
                 // TODO: somehow get the label from the containing li element
                 input({ disabled, checked }) {
@@ -138,6 +152,17 @@ exports.Markdown = (0, react_1.memo)(function Markdown({ extractValue, removeInd
                 tfoot({ children }) {
                     return (0, jsx_runtime_1.jsx)("tfoot", { className: HtmlTags_module_scss_1.default.htmlTfoot, children: children });
                 },
+                samp(_a) {
+                    var props = __rest(_a, []);
+                    const nestedProps = props;
+                    const dataContentBase64 = props === null || props === void 0 ? void 0 : props["data-pg-content"];
+                    if (dataContentBase64 !== undefined) {
+                        const jsonContent = atob(dataContentBase64);
+                        const appProps = JSON.parse(jsonContent);
+                        return ((0, jsx_runtime_1.jsx)(NestedAppNative_1.NestedApp, { app: appProps.app, config: appProps.config, components: appProps.components, api: appProps.api, activeTheme: appProps.activeTheme, activeTone: appProps.activeTone, title: appProps.name, height: appProps.height, allowPlaygroundPopup: !appProps.noPopup }));
+                    }
+                    return ((0, jsx_runtime_1.jsx)(NestedAppNative_1.NestedApp, { app: nestedProps.app, config: nestedProps.config, components: nestedProps.components, api: nestedProps.api, activeTheme: nestedProps.activeTheme, activeTone: nestedProps.activeTone, title: nestedProps.title, height: nestedProps.height, allowPlaygroundPopup: true }));
+                },
             }, children: children }) }));
 });
 function removeTextIndents(input) {
@@ -225,67 +250,3 @@ const OrderedList = ({ children, style }) => {
 const ListItem = ({ children, style }) => {
     return ((0, jsx_runtime_1.jsx)("li", { className: Markdown_module_scss_1.default.listItem, style: style, children: children }));
 };
-/**
- * Finds and evaluates given binding expressions in markdown text.
- * The binding expressions are of the form `${...}$`.
- * @param extractValue The function to resolve binding expressions
- * @returns visitor function that processes the binding expressions
- */
-function bindingExpression({ extractValue }) {
-    return (tree) => {
-        (0, unist_util_visit_1.visit)(tree, "text", (node) => {
-            return detectBindingExpression(node);
-        });
-    };
-    function detectBindingExpression(node) {
-        // Remove empty ${} expressions first
-        node.value = node.value.replace(/\$\{\s*\}/g, "");
-        const regex = /\$\{((?:[^{}]|\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*)\}/g;
-        const parts = node.value.split(regex);
-        if (parts.length > 1) {
-            node.type = "html";
-            node.value = parts
-                .map((part, index) => {
-                const extracted = index % 2 === 0 ? part : extractValue(`{${part}}`);
-                const resultExpr = mapByType(extracted);
-                // The result expression might be an object, in that case we stringify it here,
-                // at the last step, so that there are no unnecessary apostrophes
-                return typeof resultExpr === "object" && resultExpr !== null
-                    ? JSON.stringify(resultExpr)
-                    : resultExpr;
-            })
-                .join("");
-        }
-    }
-    function mapByType(extracted) {
-        if (extracted === null) {
-            return null;
-        }
-        else if (extracted === undefined || typeof extracted === "undefined") {
-            return undefined;
-        }
-        else if (typeof extracted === "object") {
-            const arrowFuncResult = parseArrowFunc(extracted);
-            if (arrowFuncResult) {
-                return arrowFuncResult;
-            }
-            if (Array.isArray(extracted)) {
-                return extracted;
-            }
-            return Object.fromEntries(Object.entries(extracted).map(([key, value]) => {
-                return [key, mapByType(value)];
-            }));
-        }
-        else {
-            return extracted;
-        }
-    }
-    function parseArrowFunc(extracted) {
-        if (extracted.hasOwnProperty("type") &&
-            extracted.type === ScriptingSourceTree_1.T_ARROW_EXPRESSION &&
-            (extracted === null || extracted === void 0 ? void 0 : extracted._ARROW_EXPR_)) {
-            return "[xmlui function]";
-        }
-        return "";
-    }
-}

package/dist/scripts/src/components/Markdown/highlight-code.js

@@ -0,0 +1,160 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeHighlighterMetaKeysData = exports.CodeHighlighterMetaKeys = void 0;
+exports.parseMetaAndHighlightCode = parseMetaAndHighlightCode;
+const react_1 = require("react");
+/**
+ * This function handles two things:
+ * 1. The extraction of meta information from code blocks and exposing them as data-meta attributes
+ * 2. The highlighting of code blocks providing the highlighter function with meta information
+ * @param node The React node containing the code block
+ * @param codeHighlighter The highlighter object containing the highlight function and the available languages
+ * @returns CSS class names for the codefence and the HTML string with highlighted code tokens
+ */
+function parseMetaAndHighlightCode(node, codeHighlighter, themeTone) {
+    const codeStr = mapTextContent(node);
+    const meta = extractMetaFromChildren(node, exports.CodeHighlighterMetaKeysData, codeStr.split("\n").length);
+    const { language } = meta, restMeta = __rest(meta, ["language"]);
+    if (language && codeHighlighter.availableLangs.includes(language)) {
+        // NOTE: Keep in mind, at this point, we are working with the markdown text
+        const htmlCodeStr = codeHighlighter.highlight(codeStr, language, restMeta, themeTone);
+        const match = htmlCodeStr.match(/<pre\b[^>]*\bclass\s*=\s*["']([^"']*)["'][^>]*>/i);
+        const classNames = match ? match[1] : null;
+        // NOTE: Why remove the <pre>?
+        // Shiki appends <pre> tags to the highlighted code,
+        // so we would get <pre><pre><code>...</code></pre></pre>
+        let cleanedHtmlStr = htmlCodeStr.replace(/<pre\b[^>]*>|<\/pre>/gi, "");
+        const numberedRowClass = meta.rowNumbers ? "numbered" : "";
+        cleanedHtmlStr = cleanedHtmlStr.replaceAll(/<span class="line"/g, `<span class="line ${numberedRowClass}"`);
+        return { classNames, cleanedHtmlStr, codeStr, meta };
+    }
+    return null;
+}
+function mapTextContent(node) {
+    if (typeof node === "string") {
+        return transformCodeLines(node);
+    }
+    if ((0, react_1.isValidElement)(node) && node.props && node.props.children) {
+        if (Array.isArray(node.props.children)) {
+            return node.props.children.map(mapTextContent).join("");
+        }
+        return mapTextContent(node.props.children);
+    }
+    return "";
+    // ---
+    function transformCodeLines(node) {
+        const splitNode = node.split(/\r?\n/);
+        for (let i = 0; i < splitNode.length; i++) {
+            // Backslash before a codefence indicates an escaped codefence
+            // -> don't render the backslash
+            if (splitNode[i].startsWith("\\```")) {
+                splitNode[i] = splitNode[i].replace("\\```", "```");
+            }
+        }
+        // Remove empty lines from start and end
+        let startTrimIdx = 0;
+        let endTrimIdx = splitNode.length - 1;
+        for (let i = 0; i < splitNode.length; i++) {
+            if (splitNode[i].trim() !== "") {
+                startTrimIdx = i;
+                break;
+            }
+        }
+        for (let i = splitNode.length - 1; i >= 0; i--) {
+            if (splitNode[i].trim() !== "") {
+                endTrimIdx = i;
+                break;
+            }
+        }
+        splitNode.splice(0, startTrimIdx);
+        splitNode.splice(endTrimIdx + 1);
+        return splitNode.join("\n");
+    }
+}
+function extractMetaFromChildren(node, keys, codeLength = 0) {
+    if (!node)
+        return {};
+    if (typeof node === "string")
+        return {};
+    if (typeof node === "number")
+        return {};
+    if (typeof node === "boolean")
+        return {};
+    if (Array.isArray(node))
+        return {};
+    if ((0, react_1.isValidElement)(node) &&
+        node.props &&
+        node.props.children &&
+        typeof node.props.children === "string") {
+        const meta = Object.entries(node.props)
+            .filter(([key, _]) => keys.includes(key))
+            .reduce((acc, [key, value]) => {
+            acc[key] = value;
+            return acc;
+        }, {});
+        return {
+            [exports.CodeHighlighterMetaKeys.language.prop]: meta[exports.CodeHighlighterMetaKeys.language.data],
+            [exports.CodeHighlighterMetaKeys.copy.prop]: parseBoolean(meta[exports.CodeHighlighterMetaKeys.copy.data]),
+            [exports.CodeHighlighterMetaKeys.filename.prop]: meta[exports.CodeHighlighterMetaKeys.filename.data],
+            [exports.CodeHighlighterMetaKeys.rowNumbers.prop]: parseBoolean(meta[exports.CodeHighlighterMetaKeys.rowNumbers.data]),
+            [exports.CodeHighlighterMetaKeys.highlightRows.prop]: meta[exports.CodeHighlighterMetaKeys.highlightRows.data]
+                ? parseRowHighlights(meta[exports.CodeHighlighterMetaKeys.highlightRows.data], codeLength)
+                : [],
+            [exports.CodeHighlighterMetaKeys.highlightSubstrings.prop]: [], // TODO
+        };
+    }
+    return {};
+}
+function parseBoolean(str) {
+    if (str === "true")
+        return true;
+    if (str === "false")
+        return false;
+    return false;
+}
+function parseRowHighlights(str, codeLines) {
+    if (str === "")
+        return [];
+    return str
+        .split(",")
+        .map((item) => {
+        item = item.trim();
+        const splitted = item.split("-");
+        const start = Number.isNaN(parseInt(splitted[0], 10)) ? -1 : parseInt(splitted[0], 10);
+        let end = 0;
+        if (splitted.length === 1) {
+            end = Number.isNaN(start + 1) ? -1 : start + 1;
+        }
+        else {
+            end = Number.isNaN(parseInt(splitted[1], 10)) ? -1 : parseInt(splitted[1], 10);
+        }
+        return { start, end };
+    })
+        .filter((item) => {
+        if (item.start === -1 || item.end === -1)
+            return false;
+        if (item.start > codeLines || item.end > codeLines)
+            return false;
+        return true;
+    });
+}
+exports.CodeHighlighterMetaKeys = {
+    language: { data: "data-language", prop: "language" },
+    copy: { data: "data-copy", prop: "copy" },
+    filename: { data: "data-filename", prop: "filename" },
+    rowNumbers: { data: "data-row-numbers", prop: "rowNumbers" },
+    highlightRows: { data: "data-highlight-rows", prop: "highlightRows" },
+    highlightSubstrings: { data: "data-highlight-substrings", prop: "highlightSubstrings" },
+};
+exports.CodeHighlighterMetaKeysData = Object.values(exports.CodeHighlighterMetaKeys).map((item) => item.data);

package/dist/scripts/src/components/Markdown/parse-binding-expr.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBindingExpression = parseBindingExpression;
+const ScriptingSourceTree_1 = require("../../abstractions/scripting/ScriptingSourceTree");
+/**
+ * Finds and evaluates given binding expressions in markdown text.
+ * The binding expressions are of the form `@{...}`.
+ * @param text The markdown text
+ * @param extractValue The function to resolve binding expressions
+ * @returns the parsed text with resolved binding expressions
+ */
+function parseBindingExpression(text, extractValue) {
+    // Remove empty @{} expressions first
+    text = text.replaceAll(/(?<!\\)\@\{\s*\}/g, "");
+    // The (?<!\\) is a "negative lookbehind" in regex that ensures that
+    // if escaping the @{...} expression like this: \@{...}, we don't match it
+    const regex = /(?<!\\)\@\{((?:[^{}]|\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*)\}/g;
+    const result = text.replace(regex, (_, expr) => {
+        const extracted = extractValue(`{${expr}}`);
+        const resultExpr = mapByType(extracted);
+        // The result expression might be an object, in that case we stringify it here,
+        // at the last step, so that there are no unnecessary apostrophes
+        return typeof resultExpr === "object" && resultExpr !== null
+            ? JSON.stringify(resultExpr)
+            : resultExpr;
+    });
+    return result;
+    // ---
+    function mapByType(extracted) {
+        if (extracted === null) {
+            return null;
+        }
+        else if (extracted === undefined || typeof extracted === "undefined") {
+            return undefined;
+        }
+        else if (typeof extracted === "object") {
+            const arrowFuncResult = parseArrowFunc(extracted);
+            if (arrowFuncResult) {
+                return arrowFuncResult;
+            }
+            if (Array.isArray(extracted)) {
+                return extracted;
+            }
+            return Object.fromEntries(Object.entries(extracted).map(([key, value]) => {
+                return [key, mapByType(value)];
+            }));
+        }
+        else {
+            return extracted;
+        }
+    }
+    function parseArrowFunc(extracted) {
+        if (extracted.hasOwnProperty("type") &&
+            extracted.type === ScriptingSourceTree_1.T_ARROW_EXPRESSION &&
+            (extracted === null || extracted === void 0 ? void 0 : extracted._ARROW_EXPR_)) {
+            return "[xmlui function]";
+        }
+        return "";
+    }
+}