@readme/markdown 14.11.1 → 14.11.3

package/dist/main.node.js

@@ -25110,6 +25110,34 @@ function useScrollHighlight(navRef) {
             return scrollParent.scrollHeight > scrollParent.clientHeight
                 && scrollParent.scrollTop + scrollParent.clientHeight >= scrollParent.scrollHeight - SCROLL_BOTTOM_TOLERANCE;
         };
+        /**
+         * Keeps the active link visible within the TOC's own scroll container —
+         * the same result as `scrollIntoView({ block: 'nearest' })`, but scoped to
+         * a single scroller. `scrollIntoView` adjusts *every* scrollable ancestor,
+         * and starting a scroll on the page's content scroller cancels any
+         * in-flight smooth scroll there — e.g. the hub's scroll-to-top reset when
+         * navigating between pages (CX-3667).
+         */
+        const scrollTOCLinkIntoView = (link) => {
+            const tocScroller = TableOfContents_getScrollParent(link);
+            // Without a TOC-local scroll area, the link's nearest scrollable
+            // ancestor is the window (`getScrollParent`'s fallback) or the scroller
+            // holding the page content — never auto-scroll those just to reveal a
+            // TOC link.
+            if (!(tocScroller instanceof HTMLElement) || tocScroller.contains(headings[0]))
+                return;
+            const scrollerRect = tocScroller.getBoundingClientRect();
+            const linkRect = link.getBoundingClientRect();
+            if (linkRect.top < scrollerRect.top) {
+                tocScroller.scrollTo?.({ top: tocScroller.scrollTop + (linkRect.top - scrollerRect.top), behavior: 'smooth' });
+            }
+            else if (linkRect.bottom > scrollerRect.bottom) {
+                tocScroller.scrollTo?.({
+                    top: tocScroller.scrollTop + (linkRect.bottom - scrollerRect.bottom),
+                    behavior: 'smooth',
+                });
+            }
+        };
         const activate = (id) => {
             if (id === activeId)
                 return;
@@ -25126,7 +25154,7 @@ function useScrollHighlight(navRef) {
                     const linkRect = link.getBoundingClientRect();
                     nav.style.setProperty('--ToC-border-active-height', `${linkRect.height}px`);
                     nav.style.setProperty('--ToC-border-active-top', `${linkRect.top - navRect.top}px`);
-                    link.scrollIntoView?.({ block: 'nearest', behavior: 'smooth' });
+                    scrollTOCLinkIntoView(link);
                 }
             }
         };
@@ -95991,6 +96019,32 @@ const applyInserts = (html, inserts) => {
     return { value: out + html.slice(cursor), inserts: sorted };
 };
 
+;// ./processor/transform/mdxish/tables/escape-stray-less-than.ts
+
+
+// A `<` only starts a JSX/HTML construct when followed by a tag-name start
+// (letter, `_`, `$`), a closer `/`, a fragment `>`, or a comment/declaration
+// `!`. Anything else (whitespace, EOL, a digit, …) is a literal `<` that acorn
+// rejects with "before name, expected a character that can start a name".
+const STRAY_LESS_THAN_RE = /<(?![a-zA-Z_$/>!])/g;
+/**
+ * Escapes stray `<` characters that don't begin a valid tag so the strict mdxjs
+ * parse treats them as literal text instead of throwing (`word <`, `a <1>`).
+ *
+ * Runs against the masked source so `<` inside code spans, legacy `<<var>>`
+ * syntax, or already-escaped `\<` are left untouched.
+ */
+const escapeStrayLessThan = (html) => {
+    const masked = maskNonTagRegions(html);
+    const inserts = [];
+    STRAY_LESS_THAN_RE.lastIndex = 0;
+    let match;
+    while ((match = STRAY_LESS_THAN_RE.exec(masked)) !== null) {
+        inserts.push({ offset: match.index, text: '\\' });
+    }
+    return applyInserts(html, inserts);
+};
+
 ;// ./processor/transform/mdxish/tables/normalize-tag-spacing.ts
 
 
@@ -96490,6 +96544,7 @@ const repairUnclosedTags = (html) => {
 
 
 
+
 
 
 const isTableCell = (node) => isMDXElement(node) && ['th', 'td'].includes(node.name);
@@ -96776,11 +96831,14 @@ const mdxishTables = () => tree => {
             //  - normalizeTagSpacing:      a line mixing text and an opening tag
             //                              (e.g. `text <div> \n <div> text`)
             //  - repairExpressionEscapes:  backslash escapes inside a `{…}` expression
+            //  - escapeStrayLessThan:      a `<` that doesn't begin a valid tag
+            //                              (e.g. `word <`, `a <1>`)
             // These repairs are created after seeing real customer content that has failed to parse
             const repairs = [
                 repairUnclosedTags,
                 normalizeTagSpacing,
                 repairExpressionEscapes,
+                escapeStrayLessThan,
             ];
             // Stops at the first repair that yields a parseable tree
             repairs.some(repair => {
@@ -118939,6 +118997,21 @@ function isActualHtmlTag(tagName, originalExcerpt) {
         return true;
     return false;
 }
+/**
+ * Re-parsing a component's text child treats it as a standalone document, so
+ * content that happens to start with the literal word `export`/`import`
+ * (e.g. link text like "export Lorem Ipsum") sits at true column 1 and
+ * gets mistaken for an MDX ESM statement, which then fails to parse as JS.
+ * Fall back to `undefined` rather than letting one such child crash the page.
+ */
+function tryProcessMarkdown(processMarkdown, content) {
+    try {
+        return processMarkdown(content);
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Parse and replace text children with processed markdown */
 function parseTextChildren(node, processMarkdown, components) {
     if (!node.children?.length)
@@ -118953,7 +119026,9 @@ function parseTextChildren(node, processMarkdown, components) {
             node.properties = { ...node.properties, children: child.value };
             return [];
         }
-        const hast = processMarkdown(child.value.trim());
+        const hast = tryProcessMarkdown(processMarkdown, child.value.trim());
+        if (!hast)
+            return [child];
         const children = (hast.children ?? []).filter(isElementContentNode);
         // For inline components, preserve plain text instead of wrapping in <p>
         if (INLINE_COMPONENT_TAGS_LOWER.has(node.tagName.toLowerCase()) && isSingleParagraphTextNode(children)) {
@@ -119027,8 +119102,9 @@ const rehypeMdxishComponents = ({ components, processMarkdown }) => {
             // rehypeRaw strips children from <img> (void element), so we must
             // re-process the caption here, after rehypeRaw.
             if (node.tagName === 'img' && typeof node.properties?.caption === 'string' && !node.children?.length) {
-                const captionHast = processMarkdown(node.properties.caption);
-                node.children = (captionHast.children ?? []).filter(isElementContentNode);
+                const caption = node.properties.caption;
+                const captionHast = tryProcessMarkdown(processMarkdown, caption);
+                node.children = captionHast ? (captionHast.children ?? []).filter(isElementContentNode) : [{ type: 'text', value: caption }];
             }
             // Skip runtime components and standard HTML tags
             if (RUNTIME_COMPONENT_TAGS.has(node.tagName))
@@ -126579,6 +126655,332 @@ const mdxishTags_tags = (doc) => {
 };
 /* harmony default export */ const mdxishTags = (mdxishTags_tags);
 
+;// ./lib/mdast-util/html-block-component/index.ts
+const html_block_component_contextMap = new WeakMap();
+function findHtmlBlockComponentToken() {
+    const events = this.tokenStack;
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        if (events[i][0].type === 'htmlBlockComponent')
+            return events[i][0];
+    }
+    return undefined;
+}
+function enterHtmlBlockComponent(token) {
+    html_block_component_contextMap.set(token, { chunks: [], lastEndLine: token.start.line });
+    this.enter({ type: 'html', value: '' }, token);
+}
+function exitHtmlBlockComponentData(token) {
+    const componentToken = findHtmlBlockComponentToken.call(this);
+    if (!componentToken)
+        return;
+    const ctx = html_block_component_contextMap.get(componentToken);
+    if (ctx) {
+        const gap = token.start.line - ctx.lastEndLine;
+        if (ctx.chunks.length > 0 && gap > 0) {
+            ctx.chunks.push('\n'.repeat(gap));
+        }
+        ctx.chunks.push(this.sliceSerialize(token));
+        ctx.lastEndLine = token.end.line;
+    }
+}
+function exitHtmlBlockComponent(token) {
+    const ctx = html_block_component_contextMap.get(token);
+    const node = this.stack[this.stack.length - 1];
+    if (ctx) {
+        node.value = ctx.chunks.join('');
+        html_block_component_contextMap.delete(token);
+    }
+    this.exit(token);
+}
+function htmlBlockComponentFromMarkdown() {
+    return {
+        enter: {
+            htmlBlockComponent: enterHtmlBlockComponent,
+        },
+        exit: {
+            htmlBlockComponentData: exitHtmlBlockComponentData,
+            htmlBlockComponent: exitHtmlBlockComponent,
+        },
+    };
+}
+
+;// ./lib/micromark/html-block-component/syntax.ts
+
+
+const TAG_SUFFIX = [
+    codes.uppercaseT,
+    codes.uppercaseM,
+    codes.uppercaseL,
+    codes.uppercaseB,
+    codes.lowercaseL,
+    codes.lowercaseO,
+    codes.lowercaseC,
+    codes.lowercaseK,
+];
+// ---------------------------------------------------------------------------
+// Shared tokenizer factory
+// ---------------------------------------------------------------------------
+/**
+ * Creates a tokenize function for `<HTMLBlock>...</HTMLBlock>`.
+ *
+ * - **flow** (block-level): supports multiline content via line continuations,
+ *   consumes trailing whitespace after the closing tag.
+ * - **text** (inline): single-line only, exits immediately after the closing tag.
+ */
+function syntax_createTokenize(mode) {
+    return function tokenize(effects, ok, nok) {
+        let depth = 1;
+        function matchChars(chars, onMatch, onFail) {
+            if (chars.length === 0)
+                return onMatch;
+            const next = (code) => {
+                if (code === chars[0]) {
+                    effects.consume(code);
+                    return matchChars(chars.slice(1), onMatch, onFail);
+                }
+                return onFail(code);
+            };
+            return next;
+        }
+        function matchTagName(onMatch, onFail) {
+            const next = (code) => {
+                if (code === codes.uppercaseH) {
+                    effects.consume(code);
+                    return matchChars(TAG_SUFFIX, onMatch, onFail);
+                }
+                return onFail(code);
+            };
+            return next;
+        }
+        return start;
+        function start(code) {
+            if (code !== codes.lessThan)
+                return nok(code);
+            effects.enter('htmlBlockComponent');
+            effects.enter('htmlBlockComponentData');
+            effects.consume(code);
+            return matchTagName(afterTagName, nok);
+        }
+        function afterTagName(code) {
+            if (code === codes.greaterThan) {
+                effects.consume(code);
+                return body;
+            }
+            if (code === codes.space || code === codes.horizontalTab) {
+                effects.consume(code);
+                return inAttributes;
+            }
+            if (mode === 'flow' && markdownLineEnding(code)) {
+                effects.exit('htmlBlockComponentData');
+                return attributeContinuationStart(code);
+            }
+            if (code === codes.slash) {
+                effects.consume(code);
+                return selfClose;
+            }
+            return nok(code);
+        }
+        function inAttributes(code) {
+            if (code === codes.greaterThan) {
+                effects.consume(code);
+                return body;
+            }
+            if (code === null) {
+                return nok(code);
+            }
+            if (markdownLineEnding(code)) {
+                if (mode === 'text')
+                    return nok(code);
+                effects.exit('htmlBlockComponentData');
+                return attributeContinuationStart(code);
+            }
+            effects.consume(code);
+            return inAttributes;
+        }
+        function attributeContinuationStart(code) {
+            return effects.check(html_block_component_syntax_nonLazyContinuationStart, attributeContinuationNonLazy, continuationAfter)(code);
+        }
+        function attributeContinuationNonLazy(code) {
+            effects.enter(types_types.lineEnding);
+            effects.consume(code);
+            effects.exit(types_types.lineEnding);
+            return attributeContinuationBefore;
+        }
+        function attributeContinuationBefore(code) {
+            if (code === null || markdownLineEnding(code)) {
+                return attributeContinuationStart(code);
+            }
+            effects.enter('htmlBlockComponentData');
+            return inAttributes(code);
+        }
+        function selfClose(code) {
+            if (code === codes.greaterThan) {
+                effects.consume(code);
+                return mode === 'flow' ? afterClose : done(code);
+            }
+            return nok(code);
+        }
+        function body(code) {
+            if (code === null)
+                return nok(code);
+            if (markdownLineEnding(code)) {
+                if (mode === 'text') {
+                    // Text constructs operate on paragraph content which spans lines
+                    effects.consume(code);
+                    return body;
+                }
+                effects.exit('htmlBlockComponentData');
+                return continuationStart(code);
+            }
+            if (code === codes.lessThan) {
+                effects.consume(code);
+                return closeSlash;
+            }
+            effects.consume(code);
+            return body;
+        }
+        function closeSlash(code) {
+            if (code === codes.slash) {
+                effects.consume(code);
+                return matchTagName(closeGt, body);
+            }
+            return matchTagName(openAfterTagName, body)(code);
+        }
+        function openAfterTagName(code) {
+            if (code === codes.greaterThan || code === codes.space || code === codes.horizontalTab) {
+                depth += 1;
+                effects.consume(code);
+                return body;
+            }
+            return body(code);
+        }
+        function closeGt(code) {
+            if (code === codes.greaterThan) {
+                depth -= 1;
+                effects.consume(code);
+                if (depth === 0) {
+                    return mode === 'flow' ? afterClose : done(code);
+                }
+                return body;
+            }
+            return body(code);
+        }
+        // -- flow-only states ---------------------------------------------------
+        function afterClose(code) {
+            if (code === null || markdownLineEnding(code)) {
+                return done(code);
+            }
+            if (code === codes.space || code === codes.horizontalTab) {
+                effects.consume(code);
+                return afterClose;
+            }
+            // Reject so the block re-parses as a paragraph, deferring to the
+            // text tokenizer which preserves trailing content in the same line.
+            return nok(code);
+        }
+        // -- flow-only: line continuation ---------------------------------------
+        function continuationStart(code) {
+            return effects.check(html_block_component_syntax_nonLazyContinuationStart, continuationStartNonLazy, continuationAfter)(code);
+        }
+        function continuationStartNonLazy(code) {
+            effects.enter(types_types.lineEnding);
+            effects.consume(code);
+            effects.exit(types_types.lineEnding);
+            return continuationBefore;
+        }
+        function continuationBefore(code) {
+            if (code === null || markdownLineEnding(code)) {
+                return continuationStart(code);
+            }
+            effects.enter('htmlBlockComponentData');
+            return body(code);
+        }
+        function continuationAfter(code) {
+            if (code === null)
+                return nok(code);
+            effects.exit('htmlBlockComponent');
+            return ok(code);
+        }
+        // -- shared exit --------------------------------------------------------
+        function done(_code) {
+            effects.exit('htmlBlockComponentData');
+            effects.exit('htmlBlockComponent');
+            return ok(_code);
+        }
+    };
+}
+// ---------------------------------------------------------------------------
+// Flow construct (block-level)
+// ---------------------------------------------------------------------------
+const html_block_component_syntax_nonLazyContinuationStart = {
+    tokenize: html_block_component_syntax_tokenizeNonLazyContinuationStart,
+    partial: true,
+};
+function resolveToHtmlBlockComponent(events) {
+    let index = events.length;
+    while (index > 0) {
+        index -= 1;
+        if (events[index][0] === 'enter' && events[index][1].type === 'htmlBlockComponent') {
+            break;
+        }
+    }
+    if (index > 1 && events[index - 2][1].type === types_types.linePrefix) {
+        events[index][1].start = events[index - 2][1].start;
+        events[index + 1][1].start = events[index - 2][1].start;
+        events.splice(index - 2, 2);
+    }
+    return events;
+}
+const htmlBlockComponentFlowConstruct = {
+    name: 'htmlBlockComponent',
+    tokenize: syntax_createTokenize('flow'),
+    resolveTo: resolveToHtmlBlockComponent,
+    concrete: true,
+};
+function html_block_component_syntax_tokenizeNonLazyContinuationStart(effects, ok, nok) {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+    return start;
+    function start(code) {
+        if (markdownLineEnding(code)) {
+            effects.enter(types_types.lineEnding);
+            effects.consume(code);
+            effects.exit(types_types.lineEnding);
+            return after;
+        }
+        return nok(code);
+    }
+    function after(code) {
+        if (self.parser.lazy[self.now().line]) {
+            return nok(code);
+        }
+        return ok(code);
+    }
+}
+// ---------------------------------------------------------------------------
+// Text construct (inline)
+// ---------------------------------------------------------------------------
+const htmlBlockComponentTextConstruct = {
+    name: 'htmlBlockComponent',
+    tokenize: syntax_createTokenize('text'),
+};
+// ---------------------------------------------------------------------------
+// Extension
+// ---------------------------------------------------------------------------
+function htmlBlockComponent() {
+    return {
+        flow: {
+            [codes.lessThan]: [htmlBlockComponentFlowConstruct],
+        },
+        text: {
+            [codes.lessThan]: [htmlBlockComponentTextConstruct],
+        },
+    };
+}
+
+;// ./lib/micromark/html-block-component/index.ts
+
+
 ;// ./lib/utils/extractMagicBlocks.ts
 /**
  * The content matching in this regex captures everything between `[block:TYPE]`
@@ -126645,19 +127047,22 @@ function restoreMagicBlocks(replaced, blocks) {
 
 
 
+
+
 /**
  * Removes Markdown and MDX comments.
  */
 async function stripComments(doc, { mdx, mdxish } = {}) {
     const { replaced, blocks } = extractMagicBlocks(doc);
     const processor = unified();
-    // we still require these two extensions because:
+    // we still require these extensions because:
     // 1. we can rely on remarkMdx to parse MDXish
     // 2. we need to parse JSX comments into mdxTextExpression nodes so that the transformers can pick them up
+    // 3. we need to claim <HTMLBlock> before htmlFlow intercepts its inner HTML tags
     if (mdxish) {
         processor
-            .data('micromarkExtensions', [jsxTable(), mdxExpression({ allowEmpty: true })])
-            .data('fromMarkdownExtensions', [jsxTableFromMarkdown(), mdxExpressionFromMarkdown()])
+            .data('micromarkExtensions', [htmlBlockComponent(), jsxTable(), mdxExpression({ allowEmpty: true })])
+            .data('fromMarkdownExtensions', [htmlBlockComponentFromMarkdown(), jsxTableFromMarkdown(), mdxExpressionFromMarkdown()])
             .data('toMarkdownExtensions', [mdxExpressionToMarkdown()]);
     }
     processor