safe-mdx 1.3.1 → 1.3.3

package/src/html/remark-mdx-jsx-normalize.ts

@@ -0,0 +1,128 @@
+import type { Root, RootContent, PhrasingContent } from 'mdast'
+import type { MdxJsxTextElement, MdxJsxFlowElement } from 'mdast-util-mdx-jsx'
+import { visitParents } from 'unist-util-visit-parents'
+import type { Node, Parent } from 'unist'
+
+// Type definitions for MDX and MDAST content types
+// type FlowContent = Blockquote | Code | Heading | Html | List | ThematicBreak | Content
+// type PhrasingContent = Break | Emphasis | Html | Image | ImageReference | InlineCode | Link | LinkReference | Strong | Text
+// type MdxJsxFlowContent = MdxJsxFlowElement | FlowContent
+// type MdxJsxPhrasingContent = MdxJsxTextElement | PhrasingContent
+
+/** Parents that require phrasing/inline children */
+const PHRASE_CONTAINERS = new Set([
+    'paragraph',
+    'heading',
+    'emphasis',
+    'strong',
+    'delete',
+    'link',
+    'linkReference',
+    'tableCell',
+    'mdxJsxTextElement', // MDX JSX text elements should contain phrasing
+])
+
+/** Parents that accept/expect flow (block) content */
+const FLOW_CONTAINERS = new Set([
+    'root',
+    'listItem',
+    'blockquote',
+    'footnoteDefinition',
+    'mdxJsxFlowElement', // MDX JSX flow elements should contain flow
+])
+
+/** Check if a node represents phrasing content */
+function isPhrasing(node: Node): boolean {
+    const phrasingTypes = new Set([
+        'text',
+        'emphasis',
+        'strong',
+        'delete',
+        'html',
+        'image',
+        'imageReference',
+        'inlineCode',
+        'link',
+        'linkReference',
+        'break',
+        'mdxJsxTextElement',
+    ])
+    return phrasingTypes.has(node.type)
+}
+
+/** Tags that are typically block-level elements */
+const blockLevelTags = new Set([
+    'div',
+    'p',
+    'blockquote',
+    'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+    'ul', 'ol', 'li',
+    'pre',
+    'hr',
+    'table', 'thead', 'tbody', 'tfoot', 'tr', 'th', 'td',
+    'section', 'article', 'aside', 'nav', 'header', 'footer', 'main',
+    'figure', 'figcaption',
+    // Notion-specific block elements
+    'callout',
+    'columns', 'column',
+    'page',
+    'database',
+    'data-source',
+    'audio', 'video', 'file', 'pdf', 'embed',
+    'synced_block', 'synced_block_reference',
+    'meeting-notes', 'summary', 'notes', 'transcript',
+    'table_of_contents',
+    'unknown',
+    'image', // Images can be block-level in Notion
+])
+
+/**
+ * remark plugin: make mdxJsx* element kinds match their context.
+ * - Inside phrasing parents → mdxJsxTextElement
+ * - Inside flow parents → mdxJsxFlowElement
+ * - Elements with block-level tag names → mdxJsxFlowElement
+ * - Elements containing non-phrasing children → mdxJsxFlowElement
+ */
+export default function remarkMdxJsxNormalize() {
+    return function transform(tree: Root) {
+        visitParents(tree, isMdxJsx, (node, ancestors) => {
+            const element = node as MdxJsxTextElement | MdxJsxFlowElement
+            const parent = ancestors[ancestors.length - 1] as Parent | undefined
+            if (!parent) return
+
+            const parentType = parent.type
+            const parentExpectsPhrasing = PHRASE_CONTAINERS.has(parentType)
+            const parentExpectsFlow = FLOW_CONTAINERS.has(parentType)
+
+            // Check element properties
+            const hasBlockTag = element.name ? blockLevelTags.has(element.name.toLowerCase()) : false
+            const children = (element.children || []) as RootContent[]
+            const containsNonPhrasing = children.some((c) => !isPhrasing(c))
+
+            // Determine desired type
+            let desired: 'mdxJsxTextElement' | 'mdxJsxFlowElement' = element.type
+
+            // Priority rules:
+            // 1. If it has a block-level tag name, it should be flow
+            // 2. If it contains non-phrasing children, it should be flow
+            // 3. Otherwise, match parent context
+            if (hasBlockTag || containsNonPhrasing) {
+                desired = 'mdxJsxFlowElement'
+            } else if (parentExpectsPhrasing) {
+                desired = 'mdxJsxTextElement'
+            } else if (parentExpectsFlow) {
+                desired = 'mdxJsxFlowElement'
+            }
+
+            // Apply the change if needed
+            if (element.type !== desired) {
+                element.type = desired
+            }
+        })
+    }
+}
+
+/** Check if a node is an MDX JSX element */
+function isMdxJsx(node: Node): boolean {
+    return node.type === 'mdxJsxTextElement' || node.type === 'mdxJsxFlowElement'
+}

package/src/html/valid-html-elements.ts

@@ -0,0 +1,65 @@
+// List of valid HTML elements that should be preserved
+// All other elements will be filtered out (return empty string)
+export const validHtmlElements = new Set([
+    // Document metadata
+    'base', 'head', 'link', 'meta', 'style', 'title',
+    
+    // Content sectioning
+    'address', 'article', 'aside', 'footer', 'header', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+    'main', 'nav', 'section',
+    
+    // Text content
+    'blockquote', 'dd', 'div', 'dl', 'dt', 'figcaption', 'figure', 'hr', 'li', 'ol', 'p', 'pre', 'ul',
+    
+    // Inline text semantics
+    'a', 'abbr', 'b', 'bdi', 'bdo', 'br', 'cite', 'code', 'data', 'dfn', 'em', 'i', 'kbd',
+    'mark', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'small', 'span', 'strong', 'sub', 'sup',
+    'time', 'u', 'var', 'wbr',
+    
+    // Image and multimedia
+    'area', 'audio', 'img', 'map', 'track', 'video',
+    
+    // Embedded content
+    'embed', 'iframe', 'object', 'param', 'picture', 'portal', 'source',
+    
+    // SVG and MathML
+    'svg', 'math', 'path', // Added 'path' from nativeTags
+    
+    // Scripting
+    'canvas', 'noscript', 'script',
+    
+    // Demarcating edits
+    'del', 'ins',
+    
+    // Table content
+    'caption', 'col', 'colgroup', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'tr',
+    
+    // Forms
+    'button', 'datalist', 'fieldset', 'form', 'input', 'label', 'legend', 'meter', 'optgroup',
+    'option', 'output', 'progress', 'select', 'textarea',
+    
+    // Interactive elements
+    'details', 'dialog', 'menu', 'summary',
+    
+    // Web Components
+    'slot', 'template',
+])
+
+// Export as an array for backward compatibility with nativeTags
+export const nativeTags = Array.from(validHtmlElements) as readonly string[]
+
+/**
+ * Convert HTML tag name to JSX component name
+ * Returns empty string if the tag is not a valid HTML element
+ */
+export function htmlTagNameConverter({ tagName }: { tagName: string }): string {
+    const lowerTag = tagName.toLowerCase()
+    
+    // Check if it's a valid HTML element
+    if (validHtmlElements.has(lowerTag)) {
+        return lowerTag
+    }
+    
+    // Return empty string for non-HTML elements
+    return ''
+}

package/src/parse.ts

@@ -5,6 +5,9 @@ import { Root, RootContent } from 'mdast'
 import { remark } from 'remark'
 import remarkGfm from 'remark-gfm'
 import remarkMdx from 'remark-mdx'
+import { parseHtmlToMdxAst } from './html/html-to-mdx-ast.js'
+
+export { parseHtmlToMdxAst }
 
 export function mdxParse(code: string) {
     const file = mdxProcessor.processSync(code)

package/src/safe-mdx.test.tsx

@@ -1,5 +1,4 @@
 import dedent from 'dedent'
-import { htmlToJsx } from 'html-to-jsx-transform'
 import React from 'react'
 import { renderToStaticMarkup } from 'react-dom/server'
 import { expect, test } from 'vitest'
@@ -29,16 +28,6 @@ function render(code, componentPropsSchema?: ComponentPropsSchema, allowClientEs
     return { result, errors: visitor.errors || [], html }
 }
 
-test('htmlToJsx', () => {
-    expect(htmlToJsx('<p x="y">')).toMatchInlineSnapshot(`"<p x="y" />"`)
-    expect(htmlToJsx('<p>text</p>')).toMatchInlineSnapshot(`"<p>text</p>"`)
-    expect(htmlToJsx('before <p>text</p>')).toMatchInlineSnapshot(
-        `"<>before <p>text</p></>"`,
-    )
-    expect(htmlToJsx('<nonexisting>text</nonexisting>')).toMatchInlineSnapshot(
-        `"<nonexisting>text</nonexisting>"`,
-    )
-})
 
 test('reference links with titles', () => {
     const code = dedent`
@@ -2269,6 +2258,66 @@ test('kitchen sink', () => {
     `)
 })
 
+test('mdx jsx with unknown components are ignored', () => {
+    // Note: In MDX, <custom-element> is treated as MDX JSX, not raw HTML
+    // Unknown JSX components are ignored completely (including their content)
+    const code = dedent`
+    # Heading with JSX
+    
+    This is a paragraph with some JSX components.
+    
+    <div>This is a valid div</div>
+    
+    <CustomElement>This unknown component should be ignored</CustomElement>
+    
+    <span className="highlight">This span is valid</span>
+    
+    <AnotherUnknown>Another unknown component content</AnotherUnknown>
+    
+    More text after JSX.
+    `
+    
+    const { html, result, errors } = render(code)
+    
+    // Check that valid HTML elements are present
+    expect(html).toContain('<div>This is a valid div</div>')
+    expect(html).toContain('<span')
+    expect(html).toContain('This span is valid</span>')
+    
+    // Check that unknown components are completely ignored
+    expect(html).not.toContain('CustomElement')
+    expect(html).not.toContain('AnotherUnknown')
+    expect(html).not.toContain('This unknown component should be ignored')
+    expect(html).not.toContain('Another unknown component content')
+    
+    // Check that errors were generated for unknown components
+    expect(errors).toHaveLength(2)
+    expect(errors[0].message).toContain('Unsupported jsx component CustomElement')
+    expect(errors[1].message).toContain('Unsupported jsx component AnotherUnknown')
+    
+    expect(result).toMatchInlineSnapshot(`
+      <React.Fragment>
+        <h1>
+          Heading with JSX
+        </h1>
+        <p>
+          This is a paragraph with some JSX components.
+        </p>
+        <div>
+          This is a valid div
+        </div>
+        <span
+          className="highlight"
+        >
+          This span is valid
+        </span>
+        <p>
+          More text after JSX.
+        </p>
+      </React.Fragment>
+    `)
+})
+
 test('code block rendering', () => {
     const code = dedent`
 `
@@ -2904,7 +2953,7 @@ test('ESM imports from https URLs', () => {
     
     // Since these are dynamic imports that only work on client, the server render should return null
     const html = renderToStaticMarkup(result)
-    expect(html).toMatchInlineSnapshot(`"<h1>Hello</h1>"`)
+    expect(html).toMatchInlineSnapshot(`"<link href="https://esm.sh" rel="dns-prefetch"/><link rel="preconnect" href="https://esm.sh"/><h1>Hello</h1>"`)
     
     expect(visitor.errors).toEqual([])
 })
@@ -3334,3 +3383,120 @@ test('jsx component with complex array props should show clear error message', (
     expect(expressionError!.message).toContain('Functions are not supported')
     expect(expressionError!.line).toBe(1)
 })
+
+test('override renderNode to wrap bold text in colored span', () => {
+    const code = dedent`
+    This is **bold text** and this is regular text.
+    
+    Another line with **more bold** content.
+    `
+    
+    const mdast = mdxParse(code)
+    const visitor = new MdastToJsx({ 
+        markdown: code, 
+        mdast, 
+        components,
+        renderNode: (node, transform) => {
+            if (node.type === 'strong') {
+                return (
+                    <span style={{ color: 'red', fontWeight: 'bold' }}>
+                        {node.children?.map(child => transform(child))}
+                    </span>
+                )
+            }
+            // Return undefined to use default rendering
+            return undefined
+        }
+    })
+    
+    const result = visitor.run()
+    const html = renderToStaticMarkup(result)
+    
+    expect(html).toMatchInlineSnapshot(`"<p>This is <span style="color:red;font-weight:bold">bold text</span> and this is regular text.</p><p>Another line with <span style="color:red;font-weight:bold">more bold</span> content.</p>"`)
+})
+
+test("skip unknown elements in raw HTML content", () => {
+  const { html } = render(`
+Some text before
+<html><body>
+<p>Valid paragraph</p>
+<unknonw>This content should be preserved</unknonw>
+<div>Valid div</div>
+<faketag>Another preserved content</faketag>
+</body></html>
+Some text after
+`);
+  expect(html).toMatchInlineSnapshot(`"<p>Some text before</p><p>Some text after</p>"`);
+});
+
+test("skip unknown elements in complex nested HTML structures", () => {
+  const { html } = render(`
+# Main Title
+
+<article>
+  <header>
+    <h1>Article Title</h1>
+    <customheader>
+      <p>This paragraph should be preserved</p>
+      <time>2024-01-01</time>
+    </customheader>
+  </header>
+  
+  <section>
+    <blockquote>
+      <p>A famous quote</p>
+      <customcite>
+        <strong>- Author Name</strong>
+        <unknowntag>
+          <em>from a book</em>
+          <span>published in <b>2024</b></span>
+        </unknowntag>
+      </customcite>
+    </blockquote>
+    
+    <fakesection>
+      <h2>Nested Heading</h2>
+      <ul>
+        <li>First item with <invalidtag>nested <code>code</code></invalidtag></li>
+        <li>Second item</li>
+        <customli>Third item should show</customli>
+      </ul>
+    </fakesection>
+  </section>
+  
+  <footer>
+    <customfooter>
+      <nav>
+        <a href="#top">Back to top</a>
+        <fakelink>
+          <span>Contact us</span>
+        </fakelink>
+      </nav>
+    </customfooter>
+  </footer>
+</article>
+
+## Another Section
+
+<div>
+  <customelement>
+    <table>
+      <thead>
+        <tr>
+          <th>Header 1</th>
+          <customth>Header 2 content</customth>
+        </tr>
+      </thead>
+      <tbody>
+        <customrow>
+          <td>Cell 1</td>
+          <td>Cell 2</td>
+        </customrow>
+      </tbody>
+    </table>
+  </customelement>
+</div>
+`);
+  
+  expect(html).toMatchInlineSnapshot(`"<h1>Main Title</h1><article><header><h1>Article Title</h1></header><section><blockquote><p>A famous quote</p></blockquote></section><footer></footer></article><h2>Another Section</h2><div></div>"`);
+});

package/src/safe-mdx.tsx

@@ -1,25 +1,16 @@
-import React, { Suspense, cloneElement } from 'react'
+import React, { cloneElement } from 'react'
 
 import type { StandardSchemaV1 } from '@standard-schema/spec'
+import type { JSXElement } from 'estree-jsx'
+import Evaluate from 'eval-estree-expression'
 import type { Node, Parent, Root, RootContent } from 'mdast'
 import type { MdxJsxFlowElement, MdxJsxTextElement } from 'mdast-util-mdx-jsx'
-import type {
-    JSXElement,
-    JSXAttribute,
-    JSXText,
-    JSXExpressionContainer,
-} from 'estree-jsx'
-import Evaluate from 'eval-estree-expression'
 
 import { Fragment, ReactNode } from 'react'
 import { DynamicEsmComponent } from './dynamic-esm-component.js'
-import { parseEsmImports, extractComponentInfo } from './esm-parser.js'
-
-const HtmlToJsxConverter = React.lazy(() =>
-    import('./HtmlToJsxConverter.js').then((module) => ({
-        default: module.HtmlToJsxConverter,
-    })),
-)
+import { extractComponentInfo, parseEsmImports } from './esm-parser.js'
+import { htmlToMdxAst } from './html/html-to-mdx-ast.js'
+import { validHtmlElements, nativeTags } from './html/valid-html-elements.js'
 
 export type MyRootContent = RootContent | Root
 
@@ -258,7 +249,10 @@ export class MdastToJsx {
 
                     return this.createElement(
                         Component,
-                        this.addLineNumberToProps({ ...attrs, importUrl, componentName }, node),
+                        this.addLineNumberToProps(
+                            { ...attrs, importUrl, componentName },
+                            node,
+                        ),
                         this.mapJsxChildren(node),
                     )
                 } else {
@@ -444,7 +438,11 @@ export class MdastToJsx {
                                 onError({
                                     message: `Failed to evaluate expression attribute: ${attr.value
                                         .replace(/\n+/g, ' ')
-                                        .replace(/ +/g, ' ')}. ${error instanceof Error ? error.message : String(error)}`,
+                                        .replace(/ +/g, ' ')}. ${
+                                        error instanceof Error
+                                            ? error.message
+                                            : String(error)
+                                    }`,
                                     line: attr.position?.start?.line,
                                 })
                             }
@@ -453,7 +451,11 @@ export class MdastToJsx {
                         onError({
                             message: `Failed to evaluate expression attribute: ${attr.value
                                 .replace(/\n+/g, ' ')
-                                .replace(/ +/g, ' ')}. ${error instanceof Error ? error.message : String(error)}`,
+                                .replace(/ +/g, ' ')}. ${
+                                error instanceof Error
+                                    ? error.message
+                                    : String(error)
+                            }`,
                             line: attr.position?.start?.line,
                         })
                     }
@@ -536,7 +538,13 @@ export class MdastToJsx {
                                 continue
                             } catch (error) {
                                 onError({
-                                    message: `Failed to evaluate expression attribute: ${attr.name}={${v.value}}. ${error instanceof Error ? error.message : String(error)}`,
+                                    message: `Failed to evaluate expression attribute: ${
+                                        attr.name
+                                    }={${v.value}}. ${
+                                        error instanceof Error
+                                            ? error.message
+                                            : String(error)
+                                    }`,
                                     line: attr.position?.start?.line,
                                 })
                             }
@@ -634,14 +642,26 @@ export class MdastToJsx {
                                 return result
                             } catch (error) {
                                 this.errors.push({
-                                    message: `Failed to evaluate expression: ${node.value}. ${error instanceof Error ? error.message : String(error)}`,
+                                    message: `Failed to evaluate expression: ${
+                                        node.value
+                                    }. ${
+                                        error instanceof Error
+                                            ? error.message
+                                            : String(error)
+                                    }`,
                                     line: node.position?.start?.line,
                                 })
                             }
                         }
                     } catch (error) {
                         this.errors.push({
-                            message: `Failed to evaluate expression: ${node.value}. ${error instanceof Error ? error.message : String(error)}`,
+                            message: `Failed to evaluate expression: ${
+                                node.value
+                            }. ${
+                                error instanceof Error
+                                    ? error.message
+                                    : String(error)
+                            }`,
                             line: node.position?.start?.line,
                         })
                     }
@@ -908,15 +928,26 @@ export class MdastToJsx {
                     return []
                 }
 
-                return this.createElement(
-                    Suspense,
-                    { fallback: null },
-                    this.createElement(HtmlToJsxConverter, {
-                        htmlText: text,
-                        instance: this,
-                        node,
-                    }),
-                )
+                // Parse HTML to MDX AST using the new approach
+                const mdxAst = htmlToMdxAst({
+                    html: text,
+                    convertTagName: ({ tagName }) => {
+                        const lowerTag = tagName.toLowerCase()
+                        // Only keep valid HTML elements
+                        if (validHtmlElements.has(lowerTag)) {
+                            return lowerTag
+                        }
+                        // Return empty string for non-HTML elements
+                        return ''
+                    }
+                })
+
+                // Process the MDX AST nodes
+                if (Array.isArray(mdxAst)) {
+                    return mdxAst.map(child => this.mdastTransformer(child))
+                } else {
+                    return this.mdastTransformer(mdxAst)
+                }
             }
             case 'imageReference': {
                 return []
@@ -978,69 +1009,6 @@ function safeJsonParse(str: string) {
     }
 }
 
-const nativeTags = [
-    'blockquote',
-    'strong',
-    'em',
-    'del',
-    'hr',
-    'a',
-    'b',
-    'br',
-    'button',
-    'div',
-    'form',
-    'h1',
-    'h2',
-    'h3',
-    'h4',
-    'head',
-    'iframe',
-    'img',
-    'input',
-    'label',
-    'li',
-    'link',
-    'ol',
-    'p',
-    'path',
-    'picture',
-    'script',
-    'section',
-    'source',
-    'span',
-    'sub',
-    'sup',
-    'svg',
-    'table',
-    'tbody',
-    'td',
-    'tfoot',
-    'th',
-    'thead',
-    'tr',
-    'ul',
-    'video',
-    'code',
-    'pre',
-    'figure',
-    'canvas',
-    'details',
-    'dl',
-    'dt',
-    'dd',
-    'fieldset',
-    'footer',
-    'header',
-    'legend',
-    'main',
-    'mark',
-    'nav',
-    'progress',
-    'summary',
-    'time',
-] as const
-
 type ComponentsMap = { [k in (typeof nativeTags)[number]]?: any } & {
     [key: string]: any
 }

package/dist/HtmlToJsxConverter.d.ts

@@ -1,10 +0,0 @@
-import React from 'react';
-import type { MdastToJsx, MyRootContent } from './safe-mdx.js';
-interface HtmlToJsxConverterProps {
-    htmlText: string;
-    instance: MdastToJsx;
-    node: MyRootContent;
-}
-export declare function HtmlToJsxConverter({ htmlText, instance, node, }: HtmlToJsxConverterProps): string | number | bigint | true | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode>>;
-export {};
-//# sourceMappingURL=HtmlToJsxConverter.d.ts.map

package/dist/HtmlToJsxConverter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HtmlToJsxConverter.d.ts","sourceRoot":"","sources":["../src/HtmlToJsxConverter.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAI9D,UAAU,uBAAuB;IAC7B,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,UAAU,CAAA;IACpB,IAAI,EAAE,aAAa,CAAA;CACtB;AAED,wBAAgB,kBAAkB,CAAC,EAC/B,QAAQ,EACR,QAAQ,EACR,IAAI,GACP,EAAE,uBAAuB,+SAoBzB"}

package/dist/HtmlToJsxConverter.js

@@ -1,22 +0,0 @@
-import React from 'react';
-import { htmlToJsx } from 'html-to-jsx-transform';
-React;
-export function HtmlToJsxConverter({ htmlText, instance, node, }) {
-    try {
-        const jsx = htmlToJsx(htmlText);
-        const originalJsxStr = instance.jsxStr;
-        instance.jsxStr = jsx;
-        const result = instance.jsxTransformer(node);
-        instance.jsxStr = originalJsxStr;
-        if (Array.isArray(result)) {
-            console.log(`Unexpected array result`);
-            return null;
-        }
-        return result || null;
-    }
-    catch (error) {
-        console.error('Error converting HTML to JSX:', error);
-        return null;
-    }
-}
-//# sourceMappingURL=HtmlToJsxConverter.js.map

package/dist/HtmlToJsxConverter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"HtmlToJsxConverter.js","sourceRoot":"","sources":["../src/HtmlToJsxConverter.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AACzB,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAGjD,KAAK,CAAA;AAQL,MAAM,UAAU,kBAAkB,CAAC,EAC/B,QAAQ,EACR,QAAQ,EACR,IAAI,GACkB;IACtB,IAAI;QACA,MAAM,GAAG,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAA;QAC/B,MAAM,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAA;QACtC,QAAQ,CAAC,MAAM,GAAG,GAAG,CAAA;QAErB,MAAM,MAAM,GAAG,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,CAAA;QAE5C,QAAQ,CAAC,MAAM,GAAG,cAAc,CAAA;QAEhC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YACvB,OAAO,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAA;YACtC,OAAO,IAAI,CAAA;SACd;QAED,OAAO,MAAM,IAAI,IAAI,CAAA;KACxB;IAAC,OAAO,KAAK,EAAE;QACZ,OAAO,CAAC,KAAK,CAAC,+BAA+B,EAAE,KAAK,CAAC,CAAA;QACrD,OAAO,IAAI,CAAA;KACd;AACL,CAAC"}