@readme/markdown 14.11.1 → 14.11.3

package/dist/render-fixture.node.js

@@ -92021,6 +92021,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;
@@ -92037,7 +92065,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);
                 }
             }
         };
@@ -92812,7 +92840,7 @@ function legacyVariableFromMarkdown() {
  *
  * Unicode basic latin block.
  */
-const codes = /** @type {const} */ ({
+const codes_codes = /** @type {const} */ ({
   carriageReturn: -5,
   lineFeed: -4,
   carriageReturnLineFeed: -3,
@@ -92960,11 +92988,11 @@ const codes = /** @type {const} */ ({
 function isNameChar(code) {
     if (code === null)
         return false;
-    return ((code >= codes.lowercaseA && code <= codes.lowercaseZ) ||
-        (code >= codes.uppercaseA && code <= codes.uppercaseZ) ||
-        (code >= codes.digit0 && code <= codes.digit9) ||
-        code === codes.dash ||
-        code === codes.underscore);
+    return ((code >= codes_codes.lowercaseA && code <= codes_codes.lowercaseZ) ||
+        (code >= codes_codes.uppercaseA && code <= codes_codes.uppercaseZ) ||
+        (code >= codes_codes.digit0 && code <= codes_codes.digit9) ||
+        code === codes_codes.dash ||
+        code === codes_codes.underscore);
 }
 const gemojiConstruct = {
     name: 'gemoji',
@@ -92974,7 +93002,7 @@ function tokenize(effects, ok, nok) {
     let hasName = false;
     // Entry point — expect opening `:`
     const start = (code) => {
-        if (code !== codes.colon)
+        if (code !== codes_codes.colon)
             return nok(code);
         effects.enter('gemoji');
         effects.enter('gemojiMarker');
@@ -92985,7 +93013,7 @@ function tokenize(effects, ok, nok) {
     };
     // First char after `:`, branch on `+` for :+1:, otherwise start normal name
     const nameStart = (code) => {
-        if (code === codes.plusSign) {
+        if (code === codes_codes.plusSign) {
             effects.consume(code); // +
             return plusOne;
         }
@@ -93000,7 +93028,7 @@ function tokenize(effects, ok, nok) {
     // After `+`, only `1` is valid (for :+1:), anything else rejects
     // this is a special case for :+1: 👍 since + isnt a normal name character
     const plusOne = (code) => {
-        if (code === codes.digit1) {
+        if (code === codes_codes.digit1) {
             hasName = true;
             effects.consume(code); // 1
             return nameEnd;
@@ -93009,7 +93037,7 @@ function tokenize(effects, ok, nok) {
     };
     // Consume name characters until we hit closing `:` or an invalid char
     const name = (code) => {
-        if (code === codes.colon) {
+        if (code === codes_codes.colon) {
             if (!hasName)
                 return nok(code);
             return nameEnd(code);
@@ -93023,7 +93051,7 @@ function tokenize(effects, ok, nok) {
     };
     // Expect closing `:`
     const nameEnd = (code) => {
-        if (code !== codes.colon)
+        if (code !== codes_codes.colon)
             return nok(code);
         effects.exit('gemojiName');
         effects.enter('gemojiMarker');
@@ -93036,7 +93064,7 @@ function tokenize(effects, ok, nok) {
 }
 function syntax_gemoji() {
     return {
-        text: { [codes.colon]: gemojiConstruct },
+        text: { [codes_codes.colon]: gemojiConstruct },
     };
 }
 
@@ -93051,8 +93079,8 @@ function syntax_gemoji() {
 
 function isAllowedValueChar(code) {
     return (code !== null &&
-        code !== codes.lessThan &&
-        code !== codes.greaterThan &&
+        code !== codes_codes.lessThan &&
+        code !== codes_codes.greaterThan &&
         !markdownLineEnding(code));
 }
 const legacyVariableConstruct = {
@@ -93062,7 +93090,7 @@ const legacyVariableConstruct = {
 function syntax_tokenize(effects, ok, nok) {
     let hasValue = false;
     const start = (code) => {
-        if (code !== codes.lessThan)
+        if (code !== codes_codes.lessThan)
             return nok(code);
         effects.enter('legacyVariable');
         effects.enter('legacyVariableMarkerStart');
@@ -93070,7 +93098,7 @@ function syntax_tokenize(effects, ok, nok) {
         return open2;
     };
     const open2 = (code) => {
-        if (code !== codes.lessThan)
+        if (code !== codes_codes.lessThan)
             return nok(code);
         effects.consume(code); // <<
         effects.exit('legacyVariableMarkerStart');
@@ -93078,7 +93106,7 @@ function syntax_tokenize(effects, ok, nok) {
         return value;
     };
     const value = (code) => {
-        if (code === codes.greaterThan) {
+        if (code === codes_codes.greaterThan) {
             if (!hasValue)
                 return nok(code);
             effects.exit('legacyVariableValue');
@@ -93093,7 +93121,7 @@ function syntax_tokenize(effects, ok, nok) {
         return value;
     };
     const close2 = (code) => {
-        if (code !== codes.greaterThan)
+        if (code !== codes_codes.greaterThan)
             return nok(code);
         effects.consume(code); // >>
         effects.exit('legacyVariableMarkerEnd');
@@ -93104,7 +93132,7 @@ function syntax_tokenize(effects, ok, nok) {
 }
 function legacyVariable() {
     return {
-        text: { [codes.lessThan]: legacyVariableConstruct },
+        text: { [codes_codes.lessThan]: legacyVariableConstruct },
     };
 }
 
@@ -95942,6 +95970,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
 
 
@@ -96441,6 +96495,7 @@ const repairUnclosedTags = (html) => {
 
 
 
+
 
 
 const isTableCell = (node) => utils_isMDXElement(node) && ['th', 'td'].includes(node.name);
@@ -96727,11 +96782,14 @@ const mdxish_tables_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 => {
@@ -117470,6 +117528,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)
@@ -117484,7 +117557,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)) {
@@ -117558,8 +117633,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))
@@ -118288,7 +118364,7 @@ const KNOWN_BLOCK_TYPES = new Set([
  * Types can contain alphanumeric characters and hyphens (e.g., "api-header", "tutorial-tile")
  */
 function isTypeChar(code) {
-    return asciiAlphanumeric(code) || code === codes.dash;
+    return asciiAlphanumeric(code) || code === codes_codes.dash;
 }
 /**
  * Creates the opening marker state machine: [block:
@@ -118296,37 +118372,37 @@ function isTypeChar(code) {
  */
 function createOpeningMarkerParser(effects, nok, onComplete) {
     const expectB = (code) => {
-        if (code !== codes.lowercaseB)
+        if (code !== codes_codes.lowercaseB)
             return nok(code);
         effects.consume(code);
         return expectL;
     };
     const expectL = (code) => {
-        if (code !== codes.lowercaseL)
+        if (code !== codes_codes.lowercaseL)
             return nok(code);
         effects.consume(code);
         return expectO;
     };
     const expectO = (code) => {
-        if (code !== codes.lowercaseO)
+        if (code !== codes_codes.lowercaseO)
             return nok(code);
         effects.consume(code);
         return expectC;
     };
     const expectC = (code) => {
-        if (code !== codes.lowercaseC)
+        if (code !== codes_codes.lowercaseC)
             return nok(code);
         effects.consume(code);
         return expectK;
     };
     const expectK = (code) => {
-        if (code !== codes.lowercaseK)
+        if (code !== codes_codes.lowercaseK)
             return nok(code);
         effects.consume(code);
         return expectColon;
     };
     const expectColon = (code) => {
-        if (code !== codes.colon)
+        if (code !== codes_codes.colon)
             return nok(code);
         effects.consume(code);
         effects.exit('magicBlockMarkerStart');
@@ -118342,7 +118418,7 @@ function createOpeningMarkerParser(effects, nok, onComplete) {
 function createTypeCaptureParser(effects, nok, onComplete, blockTypeRef) {
     const captureTypeFirst = (code) => {
         // Reject empty type name [block:]
-        if (code === codes.rightSquareBracket) {
+        if (code === codes_codes.rightSquareBracket) {
             return nok(code);
         }
         if (isTypeChar(code)) {
@@ -118353,7 +118429,7 @@ function createTypeCaptureParser(effects, nok, onComplete, blockTypeRef) {
         return nok(code);
     };
     const captureType = (code) => {
-        if (code === codes.rightSquareBracket) {
+        if (code === codes_codes.rightSquareBracket) {
             if (!KNOWN_BLOCK_TYPES.has(blockTypeRef.value)) {
                 return nok(code);
             }
@@ -118378,7 +118454,7 @@ function createTypeCaptureParser(effects, nok, onComplete, blockTypeRef) {
  */
 function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonState) {
     const handleMismatch = (code) => {
-        if (jsonState && code === codes.quotationMark) {
+        if (jsonState && code === codes_codes.quotationMark) {
             jsonState.inString = true;
         }
         return onMismatch(code);
@@ -118386,7 +118462,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectSlash = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes.slash)
+        if (code !== codes_codes.slash)
             return handleMismatch(code);
         effects.consume(code);
         return expectB;
@@ -118394,7 +118470,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectB = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes.lowercaseB)
+        if (code !== codes_codes.lowercaseB)
             return handleMismatch(code);
         effects.consume(code);
         return expectL;
@@ -118402,7 +118478,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectL = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes.lowercaseL)
+        if (code !== codes_codes.lowercaseL)
             return handleMismatch(code);
         effects.consume(code);
         return expectO;
@@ -118410,7 +118486,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectO = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes.lowercaseO)
+        if (code !== codes_codes.lowercaseO)
             return handleMismatch(code);
         effects.consume(code);
         return expectC;
@@ -118418,7 +118494,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectC = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes.lowercaseC)
+        if (code !== codes_codes.lowercaseC)
             return handleMismatch(code);
         effects.consume(code);
         return expectK;
@@ -118426,7 +118502,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectK = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes.lowercaseK)
+        if (code !== codes_codes.lowercaseK)
             return handleMismatch(code);
         effects.consume(code);
         return expectBracket;
@@ -118434,7 +118510,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectBracket = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes.rightSquareBracket)
+        if (code !== codes_codes.rightSquareBracket)
             return handleMismatch(code);
         effects.consume(code);
         return onSuccess;
@@ -118490,7 +118566,7 @@ function syntax_magicBlock() {
         // Flow construct - handles block-level magic blocks at document root
         // Marked as concrete to prevent interruption by containers
         flow: {
-            [codes.leftSquareBracket]: {
+            [codes_codes.leftSquareBracket]: {
                 name: 'magicBlock',
                 concrete: true,
                 tokenize: tokenizeMagicBlockFlow,
@@ -118498,7 +118574,7 @@ function syntax_magicBlock() {
         },
         // Text construct - handles magic blocks in inline contexts (lists, paragraphs)
         text: {
-            [codes.leftSquareBracket]: {
+            [codes_codes.leftSquareBracket]: {
                 name: 'magicBlock',
                 tokenize: tokenizeMagicBlockText,
             },
@@ -118519,7 +118595,7 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
     const openingMarkerParser = createOpeningMarkerParser(effects, nok, typeParser.first);
     return start;
     function start(code) {
-        if (code !== codes.leftSquareBracket)
+        if (code !== codes_codes.leftSquareBracket)
             return nok(code);
         effects.enter('magicBlock');
         effects.enter('magicBlockMarkerStart');
@@ -118542,7 +118618,7 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
         // Check for closing marker directly (without entering data)
         // This handles cases like [block:type]\n{}\n\n[/block] where there are
         // newlines after the data object
-        if (code === codes.leftSquareBracket) {
+        if (code === codes_codes.leftSquareBracket) {
             effects.enter('magicBlockMarkerEnd');
             effects.consume(code);
             return expectSlashFromContinuation;
@@ -118554,11 +118630,11 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
         }
         // Skip whitespace (spaces/tabs) before the data - stay in beforeData
         // Don't enter magicBlockData token yet until we confirm there's a '{'
-        if (code === codes.space || code === codes.horizontalTab) {
+        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
             return beforeDataWhitespace(code);
         }
         // Data must start with '{' for valid JSON
-        if (code !== codes.leftCurlyBrace) {
+        if (code !== codes_codes.leftCurlyBrace) {
             effects.exit('magicBlock');
             return nok(code);
         }
@@ -118579,14 +118655,14 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
         if (markdownLineEnding(code)) {
             return effects.check(syntax_nonLazyContinuation, continuationOkBeforeData, after)(code);
         }
-        if (code === codes.space || code === codes.horizontalTab) {
+        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
             // We need to consume this but can't without a token - use magicBlockData
             // and track that we haven't seen '{' yet
             effects.enter('magicBlockData');
             effects.consume(code);
             return beforeDataWhitespaceContinue;
         }
-        if (code === codes.leftCurlyBrace) {
+        if (code === codes_codes.leftCurlyBrace) {
             seenOpenBrace = true;
             effects.enter('magicBlockData');
             return captureData(code);
@@ -118607,11 +118683,11 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlockData');
             return effects.check(syntax_nonLazyContinuation, continuationOk, after)(code);
         }
-        if (code === codes.space || code === codes.horizontalTab) {
+        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
             effects.consume(code);
             return beforeDataWhitespaceContinue;
         }
-        if (code === codes.leftCurlyBrace) {
+        if (code === codes_codes.leftCurlyBrace) {
             seenOpenBrace = true;
             return captureData(code);
         }
@@ -118646,23 +118722,23 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             return captureData;
         }
         if (jsonState.inString) {
-            if (code === codes.backslash) {
+            if (code === codes_codes.backslash) {
                 jsonState.escapeNext = true;
                 effects.consume(code);
                 return captureData;
             }
-            if (code === codes.quotationMark) {
+            if (code === codes_codes.quotationMark) {
                 jsonState.inString = false;
             }
             effects.consume(code);
             return captureData;
         }
-        if (code === codes.quotationMark) {
+        if (code === codes_codes.quotationMark) {
             jsonState.inString = true;
             effects.consume(code);
             return captureData;
         }
-        if (code === codes.leftSquareBracket) {
+        if (code === codes_codes.leftSquareBracket) {
             effects.exit('magicBlockData');
             effects.enter('magicBlockMarkerEnd');
             effects.consume(code);
@@ -118695,7 +118771,7 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
         }
         // Check if this is the start of the closing marker [/block]
         // If so, handle it directly without entering magicBlockData
-        if (code === codes.leftSquareBracket) {
+        if (code === codes_codes.leftSquareBracket) {
             effects.enter('magicBlockMarkerEnd');
             effects.consume(code);
             return expectSlashFromContinuation;
@@ -118717,7 +118793,7 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlockMarkerEnd');
             return effects.check(syntax_nonLazyContinuation, continuationOkBeforeData, after)(code);
         }
-        if (code === codes.slash) {
+        if (code === codes_codes.slash) {
             effects.consume(code);
             return expectClosingB;
         }
@@ -118728,7 +118804,7 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
         // The [ was consumed by the marker, so we need to conceptually "have it" in our data
         // But since we already consumed it into the marker, we need a different approach
         // Re-classify: consume this character as data and continue
-        if (code === codes.quotationMark)
+        if (code === codes_codes.quotationMark)
             jsonState.inString = true;
         effects.consume(code);
         return captureData;
@@ -118744,10 +118820,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlockMarkerEnd');
             return effects.check(syntax_nonLazyContinuation, continuationOk, after)(code);
         }
-        if (code !== codes.slash) {
+        if (code !== codes_codes.slash) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes.quotationMark)
+            if (code === codes_codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -118761,10 +118837,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlock');
             return nok(code);
         }
-        if (code !== codes.lowercaseB) {
+        if (code !== codes_codes.lowercaseB) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes.quotationMark)
+            if (code === codes_codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -118778,10 +118854,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlock');
             return nok(code);
         }
-        if (code !== codes.lowercaseL) {
+        if (code !== codes_codes.lowercaseL) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes.quotationMark)
+            if (code === codes_codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -118795,10 +118871,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlock');
             return nok(code);
         }
-        if (code !== codes.lowercaseO) {
+        if (code !== codes_codes.lowercaseO) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes.quotationMark)
+            if (code === codes_codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -118812,10 +118888,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlock');
             return nok(code);
         }
-        if (code !== codes.lowercaseC) {
+        if (code !== codes_codes.lowercaseC) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes.quotationMark)
+            if (code === codes_codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -118829,10 +118905,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlock');
             return nok(code);
         }
-        if (code !== codes.lowercaseK) {
+        if (code !== codes_codes.lowercaseK) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes.quotationMark)
+            if (code === codes_codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -118846,10 +118922,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlock');
             return nok(code);
         }
-        if (code !== codes.rightSquareBracket) {
+        if (code !== codes_codes.rightSquareBracket) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes.quotationMark)
+            if (code === codes_codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -118876,7 +118952,7 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             return ok(code);
         }
         // Space or tab - consume as trailing whitespace
-        if (code === codes.space || code === codes.horizontalTab) {
+        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
             effects.enter('magicBlockTrailing');
             effects.consume(code);
             return consumeTrailingContinue;
@@ -118902,7 +118978,7 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             return ok(code);
         }
         // More space or tab - keep consuming
-        if (code === codes.space || code === codes.horizontalTab) {
+        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
             effects.consume(code);
             return consumeTrailingContinue;
         }
@@ -118942,7 +119018,7 @@ function tokenizeMagicBlockText(effects, ok, nok) {
     const closingMismatch = (code) => {
         effects.exit('magicBlockMarkerEnd');
         effects.enter('magicBlockData');
-        if (code === codes.quotationMark)
+        if (code === codes_codes.quotationMark)
             jsonState.inString = true;
         effects.consume(code);
         return captureData;
@@ -118954,7 +119030,7 @@ function tokenizeMagicBlockText(effects, ok, nok) {
     const closingFromData = createClosingMarkerParser(effects, closingSuccess, closingMismatch, closingEof, jsonState);
     return start;
     function start(code) {
-        if (code !== codes.leftSquareBracket)
+        if (code !== codes_codes.leftSquareBracket)
             return nok(code);
         effects.enter('magicBlock');
         effects.enter('magicBlockMarkerStart');
@@ -118978,7 +119054,7 @@ function tokenizeMagicBlockText(effects, ok, nok) {
             return beforeData;
         }
         // Check for closing marker directly (without entering data)
-        if (code === codes.leftSquareBracket) {
+        if (code === codes_codes.leftSquareBracket) {
             effects.enter('magicBlockMarkerEnd');
             effects.consume(code);
             return closingFromBeforeData.expectSlash;
@@ -118989,11 +119065,11 @@ function tokenizeMagicBlockText(effects, ok, nok) {
             return captureData(code);
         }
         // Skip whitespace (spaces/tabs) before the data
-        if (code === codes.space || code === codes.horizontalTab) {
+        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
             return beforeDataWhitespace(code);
         }
         // Data must start with '{' for valid JSON
-        if (code !== codes.leftCurlyBrace) {
+        if (code !== codes_codes.leftCurlyBrace) {
             return nok(code);
         }
         // We have '{' - enter data token and start capturing
@@ -119014,12 +119090,12 @@ function tokenizeMagicBlockText(effects, ok, nok) {
             effects.exit('magicBlockLineEnding');
             return beforeData;
         }
-        if (code === codes.space || code === codes.horizontalTab) {
+        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
             effects.enter('magicBlockData');
             effects.consume(code);
             return beforeDataWhitespaceContinue;
         }
-        if (code === codes.leftCurlyBrace) {
+        if (code === codes_codes.leftCurlyBrace) {
             seenOpenBrace = true;
             effects.enter('magicBlockData');
             return captureData(code);
@@ -119041,11 +119117,11 @@ function tokenizeMagicBlockText(effects, ok, nok) {
             effects.exit('magicBlockLineEnding');
             return beforeData;
         }
-        if (code === codes.space || code === codes.horizontalTab) {
+        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
             effects.consume(code);
             return beforeDataWhitespaceContinue;
         }
-        if (code === codes.leftCurlyBrace) {
+        if (code === codes_codes.leftCurlyBrace) {
             seenOpenBrace = true;
             return captureData(code);
         }
@@ -119073,23 +119149,23 @@ function tokenizeMagicBlockText(effects, ok, nok) {
             return captureData;
         }
         if (jsonState.inString) {
-            if (code === codes.backslash) {
+            if (code === codes_codes.backslash) {
                 jsonState.escapeNext = true;
                 effects.consume(code);
                 return captureData;
             }
-            if (code === codes.quotationMark) {
+            if (code === codes_codes.quotationMark) {
                 jsonState.inString = false;
             }
             effects.consume(code);
             return captureData;
         }
-        if (code === codes.quotationMark) {
+        if (code === codes_codes.quotationMark) {
             jsonState.inString = true;
             effects.consume(code);
             return captureData;
         }
-        if (code === codes.leftSquareBracket) {
+        if (code === codes_codes.leftSquareBracket) {
             effects.exit('magicBlockData');
             effects.enter('magicBlockMarkerEnd');
             effects.consume(code);
@@ -119680,11 +119756,11 @@ function createTokenize(mode) {
         // When a } brings braceDepth back to a saved value, we return to the
         // template literal instead of continuing in the brace expression.
         const templateStack = [];
-        const isAlpha = (code) => (code >= codes.uppercaseA && code <= codes.uppercaseZ) ||
-            (code >= codes.lowercaseA && code <= codes.lowercaseZ);
+        const isAlpha = (code) => (code >= codes_codes.uppercaseA && code <= codes_codes.uppercaseZ) ||
+            (code >= codes_codes.lowercaseA && code <= codes_codes.lowercaseZ);
         const isSameCaseAsTag = (code) => isLowercaseTag
-            ? code >= codes.lowercaseA && code <= codes.lowercaseZ
-            : code >= codes.uppercaseA && code <= codes.uppercaseZ;
+            ? code >= codes_codes.lowercaseA && code <= codes_codes.lowercaseZ
+            : code >= codes_codes.uppercaseA && code <= codes_codes.uppercaseZ;
         // Shared brace-expression state machine. The two call sites differ only in where
         // to continue after a line ending and where to return when braceDepth reaches zero.
         function createBraceExprStates(continuationStart, afterBraceClose) {
@@ -119697,22 +119773,22 @@ function createTokenize(mode) {
                     effects.exit('mdxComponentData');
                     return continuationStart(code);
                 }
-                if (code === codes.quotationMark || code === codes.apostrophe) {
+                if (code === codes_codes.quotationMark || code === codes_codes.apostrophe) {
                     quoteChar = code;
                     effects.consume(code);
                     return braceString;
                 }
-                if (code === codes.graveAccent) {
+                if (code === codes_codes.graveAccent) {
                     inTemplateLit = true;
                     effects.consume(code);
                     return braceTemplateLiteral;
                 }
-                if (code === codes.leftCurlyBrace) {
+                if (code === codes_codes.leftCurlyBrace) {
                     braceDepth += 1;
                     effects.consume(code);
                     return braceExpr;
                 }
-                if (code === codes.rightCurlyBrace) {
+                if (code === codes_codes.rightCurlyBrace) {
                     braceDepth -= 1;
                     effects.consume(code);
                     if (templateStack.length > 0 && braceDepth === templateStack[templateStack.length - 1]) {
@@ -119737,7 +119813,7 @@ function createTokenize(mode) {
                     effects.exit('mdxComponentData');
                     return continuationStart(code);
                 }
-                if (code === codes.backslash) {
+                if (code === codes_codes.backslash) {
                     effects.consume(code);
                     return braceStringEscape;
                 }
@@ -119765,16 +119841,16 @@ function createTokenize(mode) {
                     effects.exit('mdxComponentData');
                     return continuationStart(code);
                 }
-                if (code === codes.graveAccent) {
+                if (code === codes_codes.graveAccent) {
                     inTemplateLit = false;
                     effects.consume(code);
                     return braceExpr;
                 }
-                if (code === codes.backslash) {
+                if (code === codes_codes.backslash) {
                     effects.consume(code);
                     return braceTemplateLiteralEscape;
                 }
-                if (code === codes.dollarSign) {
+                if (code === codes_codes.dollarSign) {
                     effects.consume(code);
                     return braceTemplateLiteralDollar;
                 }
@@ -119789,7 +119865,7 @@ function createTokenize(mode) {
                 return braceTemplateLiteral;
             }
             function braceTemplateLiteralDollar(code) {
-                if (code === codes.leftCurlyBrace) {
+                if (code === codes_codes.leftCurlyBrace) {
                     templateStack.push(braceDepth);
                     braceDepth += 1;
                     inTemplateLit = false;
@@ -119805,7 +119881,7 @@ function createTokenize(mode) {
         return start;
         // ── Start ──────────────────────────────────────────────────────────────
         function start(code) {
-            if (code !== codes.lessThan)
+            if (code !== codes_codes.lessThan)
                 return nok(code);
             effects.enter('mdxComponent');
             effects.enter('mdxComponentData');
@@ -119817,7 +119893,7 @@ function createTokenize(mode) {
             // Uppercase A-Z → PascalCase MDX component. Flow mode claims block
             // components; text mode only claims inline components (Anchor, Glossary),
             // which is enforced once the full name is known in `tagNameRest`.
-            if (code !== null && code >= codes.uppercaseA && code <= codes.uppercaseZ) {
+            if (code !== null && code >= codes_codes.uppercaseA && code <= codes_codes.uppercaseZ) {
                 tagName = String.fromCharCode(code);
                 isLowercaseTag = false;
                 sawBraceAttr = false;
@@ -119827,7 +119903,7 @@ function createTokenize(mode) {
             // Lowercase a-z → HTML tag (claim only if `{...}` attr appears). In
             // flow mode, refuse to interrupt a paragraph — same rule as html-flow
             // type-7. The text variant picks these up during inline parsing.
-            if (code !== null && code >= codes.lowercaseA && code <= codes.lowercaseZ) {
+            if (code !== null && code >= codes_codes.lowercaseA && code <= codes_codes.lowercaseZ) {
                 if (isFlow && self.interrupt)
                     return nok(code);
                 tagName = String.fromCharCode(code);
@@ -119840,10 +119916,10 @@ function createTokenize(mode) {
         }
         function tagNameRest(code) {
             if (code !== null &&
-                ((code >= codes.uppercaseA && code <= codes.uppercaseZ) ||
-                    (code >= codes.lowercaseA && code <= codes.lowercaseZ) ||
-                    (code >= codes.digit0 && code <= codes.digit9) ||
-                    code === codes.underscore)) {
+                ((code >= codes_codes.uppercaseA && code <= codes_codes.uppercaseZ) ||
+                    (code >= codes_codes.lowercaseA && code <= codes_codes.lowercaseZ) ||
+                    (code >= codes_codes.digit0 && code <= codes_codes.digit9) ||
+                    code === codes_codes.underscore)) {
                 tagName += String.fromCharCode(code);
                 effects.consume(code);
                 return tagNameRest;
@@ -119878,14 +119954,14 @@ function createTokenize(mode) {
                 return openTagContinuationStart(code);
             }
             // Self-closing />
-            if (code === codes.slash) {
+            if (code === codes_codes.slash) {
                 if (requiresBraceAttr && !sawBraceAttr)
                     return nok(code);
                 effects.consume(code);
                 return selfCloseGt;
             }
             // End of opening tag
-            if (code === codes.greaterThan) {
+            if (code === codes_codes.greaterThan) {
                 if (requiresBraceAttr && !sawBraceAttr) {
                     // Plain lowercase block tags stay claimable in flow, gated per line by
                     // `plainClaimLineStart`; everything else falls through to CommonMark.
@@ -119898,13 +119974,13 @@ function createTokenize(mode) {
                 return body;
             }
             // Quoted attribute value
-            if (code === codes.quotationMark || code === codes.apostrophe) {
+            if (code === codes_codes.quotationMark || code === codes_codes.apostrophe) {
                 quoteChar = code;
                 effects.consume(code);
                 return inQuotedAttr;
             }
             // JSX expression attribute
-            if (code === codes.leftCurlyBrace) {
+            if (code === codes_codes.leftCurlyBrace) {
                 braceDepth = 1;
                 sawBraceAttr = true;
                 effects.consume(code);
@@ -119922,7 +119998,7 @@ function createTokenize(mode) {
                 effects.exit('mdxComponentData');
                 return openTagContinuationStart(code);
             }
-            if (code === codes.backslash) {
+            if (code === codes_codes.backslash) {
                 effects.consume(code);
                 return inQuotedAttrEscape;
             }
@@ -119942,7 +120018,7 @@ function createTokenize(mode) {
             return inQuotedAttr;
         }
         function selfCloseGt(code) {
-            if (code === codes.greaterThan) {
+            if (code === codes_codes.greaterThan) {
                 effects.consume(code);
                 // Self-closing tag completes the token
                 return afterClose;
@@ -119995,25 +120071,25 @@ function createTokenize(mode) {
                 atLineStart = true;
                 return bodyContinuationStart(code);
             }
-            if (code !== codes.space && code !== codes.horizontalTab) {
+            if (code !== codes_codes.space && code !== codes_codes.horizontalTab) {
                 openerLineHasContent = true;
             }
-            if (code === codes.backslash) {
+            if (code === codes_codes.backslash) {
                 effects.consume(code);
                 return bodyEscapedChar;
             }
-            if (code === codes.lessThan) {
+            if (code === codes_codes.lessThan) {
                 effects.consume(code);
                 return bodyLessThan;
             }
             // Code span tracking
-            if (code === codes.graveAccent) {
+            if (code === codes_codes.graveAccent) {
                 codeSpanOpenSize = 0;
                 return countOpenTicks(code);
             }
             // JSX expression child — track braces/template literals so the closing
             // backtick of `{`...`}` is not misread as a code span opener
-            if (code === codes.leftCurlyBrace) {
+            if (code === codes_codes.leftCurlyBrace) {
                 braceDepth = 1;
                 inTemplateLit = false;
                 effects.consume(code);
@@ -120033,14 +120109,14 @@ function createTokenize(mode) {
         }
         // ── Code span handling ─────────────────────────────────────────────────
         function countOpenTicks(code) {
-            if (code === codes.graveAccent) {
+            if (code === codes_codes.graveAccent) {
                 codeSpanOpenSize += 1;
                 effects.consume(code);
                 return countOpenTicks;
             }
             // 3+ backticks at line start = fenced code block
             if (atLineStart && codeSpanOpenSize >= 3) {
-                fenceChar = codes.graveAccent;
+                fenceChar = codes_codes.graveAccent;
                 fenceLength = codeSpanOpenSize;
                 atLineStart = false;
                 return inFencedCode(code);
@@ -120050,7 +120126,7 @@ function createTokenize(mode) {
         function inCodeSpan(code) {
             if (code === null || markdownLineEnding(code))
                 return body(code);
-            if (code === codes.graveAccent) {
+            if (code === codes_codes.graveAccent) {
                 codeSpanCloseSize = 0;
                 return countCloseTicks(code);
             }
@@ -120058,7 +120134,7 @@ function createTokenize(mode) {
             return inCodeSpan;
         }
         function countCloseTicks(code) {
-            if (code === codes.graveAccent) {
+            if (code === codes_codes.graveAccent) {
                 codeSpanCloseSize += 1;
                 effects.consume(code);
                 return countCloseTicks;
@@ -120121,7 +120197,7 @@ function createTokenize(mode) {
                 return body(code);
             }
             // Only spaces/tabs allowed after closing fence
-            if (code === codes.space || code === codes.horizontalTab) {
+            if (code === codes_codes.space || code === codes_codes.horizontalTab) {
                 effects.consume(code);
                 return fenceCloseTrailing;
             }
@@ -120130,7 +120206,7 @@ function createTokenize(mode) {
         }
         // ── Tilde fenced code detection ────────────────────────────────────────
         function bodyAfterLineStart(code) {
-            if (code === codes.tilde) {
+            if (code === codes_codes.tilde) {
                 fenceCloseLength = 1;
                 effects.consume(code);
                 return countTildes;
@@ -120139,13 +120215,13 @@ function createTokenize(mode) {
             return body(code);
         }
         function countTildes(code) {
-            if (code === codes.tilde) {
+            if (code === codes_codes.tilde) {
                 fenceCloseLength += 1;
                 effects.consume(code);
                 return countTildes;
             }
             if (fenceCloseLength >= 3) {
-                fenceChar = codes.tilde;
+                fenceChar = codes_codes.tilde;
                 fenceLength = fenceCloseLength;
                 return inFencedCode(code);
             }
@@ -120155,7 +120231,7 @@ function createTokenize(mode) {
         }
         // ── Tag detection inside body ──────────────────────────────────────────
         function bodyLessThan(code) {
-            if (code === codes.slash) {
+            if (code === codes_codes.slash) {
                 if (onOpenerLine)
                     openerLineCloses += 1;
                 effects.consume(code);
@@ -120182,10 +120258,10 @@ function createTokenize(mode) {
         // ── Nested opening tag ─────────────────────────────────────────────────
         function nestedOpenTagName(code) {
             if (code !== null &&
-                ((code >= codes.uppercaseA && code <= codes.uppercaseZ) ||
-                    (code >= codes.lowercaseA && code <= codes.lowercaseZ) ||
-                    (code >= codes.digit0 && code <= codes.digit9) ||
-                    code === codes.underscore)) {
+                ((code >= codes_codes.uppercaseA && code <= codes_codes.uppercaseZ) ||
+                    (code >= codes_codes.lowercaseA && code <= codes_codes.lowercaseZ) ||
+                    (code >= codes_codes.digit0 && code <= codes_codes.digit9) ||
+                    code === codes_codes.underscore)) {
                 closingTagName += String.fromCharCode(code);
                 effects.consume(code);
                 return nestedOpenTagName;
@@ -120193,10 +120269,10 @@ function createTokenize(mode) {
             // Same-name opener followed by a tag-end char bumps depth. A line ending
             // counts too: Prettier puts a newline right after the name (`<div\n …\n>`).
             if (closingTagName === tagName &&
-                (code === codes.greaterThan ||
-                    code === codes.slash ||
-                    code === codes.space ||
-                    code === codes.horizontalTab ||
+                (code === codes_codes.greaterThan ||
+                    code === codes_codes.slash ||
+                    code === codes_codes.space ||
+                    code === codes_codes.horizontalTab ||
                     markdownLineEnding(code))) {
                 depth += 1;
             }
@@ -120215,15 +120291,15 @@ function createTokenize(mode) {
         }
         function closingTagNameRest(code) {
             if (code !== null &&
-                ((code >= codes.uppercaseA && code <= codes.uppercaseZ) ||
-                    (code >= codes.lowercaseA && code <= codes.lowercaseZ) ||
-                    (code >= codes.digit0 && code <= codes.digit9) ||
-                    code === codes.underscore)) {
+                ((code >= codes_codes.uppercaseA && code <= codes_codes.uppercaseZ) ||
+                    (code >= codes_codes.lowercaseA && code <= codes_codes.lowercaseZ) ||
+                    (code >= codes_codes.digit0 && code <= codes_codes.digit9) ||
+                    code === codes_codes.underscore)) {
                 closingTagName += String.fromCharCode(code);
                 effects.consume(code);
                 return closingTagNameRest;
             }
-            if (closingTagName === tagName && code === codes.greaterThan) {
+            if (closingTagName === tagName && code === codes_codes.greaterThan) {
                 depth -= 1;
                 effects.consume(code);
                 if (depth === 0) {
@@ -120307,9 +120383,9 @@ function createTokenize(mode) {
         }
         // Dispatch a non-blank continuation line: fenced code at line start, else body.
         function bodyLineStart(code) {
-            if (atLineStart && code === codes.tilde)
+            if (atLineStart && code === codes_codes.tilde)
                 return bodyAfterLineStart(code);
-            if (atLineStart && code === codes.graveAccent) {
+            if (atLineStart && code === codes_codes.graveAccent) {
                 codeSpanOpenSize = 0;
                 // Leave `atLineStart` set — `countOpenTicks` needs it to tell a fence from an
                 // inline code span once the run of backticks is fully counted; it's cleared once
@@ -120324,7 +120400,7 @@ function createTokenize(mode) {
         // fence) refuses so CommonMark html-flow reparses it exactly as it does today.
         function plainClaimLineStart(code) {
             // Leading whitespace only → treat as a blank line, matching CommonMark.
-            if (code === codes.space || code === codes.horizontalTab) {
+            if (code === codes_codes.space || code === codes_codes.horizontalTab) {
                 effects.consume(code);
                 return plainClaimLineStart;
             }
@@ -120337,7 +120413,7 @@ function createTokenize(mode) {
             // paragraph that merely starts with a tag must fall back so its markdown
             // parses and rehype-raw re-nests it into the wrapper.
             if (pendingBlankLine) {
-                if (code !== codes.lessThan)
+                if (code !== codes_codes.lessThan)
                     return nok(code);
                 return effects.check(markupOnlyContinuation, plainClaimContinue, nok)(code);
             }
@@ -120390,7 +120466,7 @@ function tokenizeMarkupOnlyContinuation(effects, ok, nok) {
         return afterLessThan;
     }
     function afterLessThan(code) {
-        if (code === codes.slash) {
+        if (code === codes_codes.slash) {
             effects.consume(code);
             return afterSlash;
         }
@@ -120409,7 +120485,7 @@ function tokenizeMarkupOnlyContinuation(effects, ok, nok) {
     function scanToLineEnd(code) {
         if (code === null || markdownLineEnding(code)) {
             effects.exit(types_types.data);
-            return lastNonSpace === codes.greaterThan ? ok(code) : nok(code);
+            return lastNonSpace === codes_codes.greaterThan ? ok(code) : nok(code);
         }
         if (!markdownSpace(code))
             lastNonSpace = code;
@@ -120442,8 +120518,8 @@ function tokenizeMarkupOnlyContinuation(effects, ok, nok) {
  */
 function syntax_mdxComponent() {
     return {
-        flow: { [codes.lessThan]: [mdxComponentFlowConstruct] },
-        text: { [codes.lessThan]: [mdxComponentTextConstruct] },
+        flow: { [codes_codes.lessThan]: [mdxComponentFlowConstruct] },
+        text: { [codes_codes.lessThan]: [mdxComponentTextConstruct] },
     };
 }
 
@@ -122903,21 +122979,21 @@ function resolveEntity(name) {
 function tokenizeLooseHtmlEntity(effects, ok, nok) {
     let length = 0;
     const start = (code) => {
-        if (code !== codes.ampersand)
+        if (code !== codes_codes.ampersand)
             return nok(code);
         effects.enter('looseHtmlEntity');
         effects.consume(code);
         return afterAmpersand;
     };
     const afterAmpersand = (code) => {
-        if (code === codes.numberSign) {
+        if (code === codes_codes.numberSign) {
             effects.consume(code);
             return afterHash;
         }
         return accumulateNamed(code);
     };
     const afterHash = (code) => {
-        if (code === codes.lowercaseX || code === codes.uppercaseX) {
+        if (code === codes_codes.lowercaseX || code === codes_codes.uppercaseX) {
             effects.consume(code);
             return accumulateHex;
         }
@@ -122931,7 +123007,7 @@ function tokenizeLooseHtmlEntity(effects, ok, nok) {
         }
         if (length === 0)
             return nok(code);
-        if (code === codes.semicolon)
+        if (code === codes_codes.semicolon)
             return nok(code);
         effects.exit('looseHtmlEntity');
         return ok(code);
@@ -122944,7 +123020,7 @@ function tokenizeLooseHtmlEntity(effects, ok, nok) {
         }
         if (length === 0)
             return nok(code);
-        if (code === codes.semicolon)
+        if (code === codes_codes.semicolon)
             return nok(code);
         effects.exit('looseHtmlEntity');
         return ok(code);
@@ -122957,7 +123033,7 @@ function tokenizeLooseHtmlEntity(effects, ok, nok) {
         }
         if (length === 0)
             return nok(code);
-        if (code === codes.semicolon)
+        if (code === codes_codes.semicolon)
             return nok(code);
         effects.exit('looseHtmlEntity');
         return ok(code);
@@ -122992,7 +123068,7 @@ function exitLooseHtmlEntity(token) {
 }
 function looseHtmlEntity() {
     return {
-        text: { [codes.ampersand]: looseHtmlEntityConstruct },
+        text: { [codes_codes.ampersand]: looseHtmlEntityConstruct },
     };
 }
 function looseHtmlEntityFromMarkdown() {
@@ -125349,7 +125425,7 @@ function jsx_table_jsxTableFromMarkdown() {
 function tokenizeJsxComment(effects, ok, nok) {
     return start;
     function start(code) {
-        if (code !== codes.leftCurlyBrace)
+        if (code !== codes_codes.leftCurlyBrace)
             return nok(code);
         effects.enter('mdxFlowExpression');
         effects.enter('mdxFlowExpressionMarker');
@@ -125358,7 +125434,7 @@ function tokenizeJsxComment(effects, ok, nok) {
         return expectSlash;
     }
     function expectSlash(code) {
-        if (code !== codes.slash) {
+        if (code !== codes_codes.slash) {
             effects.exit('mdxFlowExpression');
             return nok(code);
         }
@@ -125367,7 +125443,7 @@ function tokenizeJsxComment(effects, ok, nok) {
         return expectStar;
     }
     function expectStar(code) {
-        if (code !== codes.asterisk) {
+        if (code !== codes_codes.asterisk) {
             effects.exit('mdxFlowExpressionChunk');
             effects.exit('mdxFlowExpression');
             return nok(code);
@@ -125394,7 +125470,7 @@ function tokenizeJsxComment(effects, ok, nok) {
             effects.exit('mdxFlowExpressionChunk');
             return before(code);
         }
-        if (code === codes.asterisk) {
+        if (code === codes_codes.asterisk) {
             effects.consume(code);
             return maybeClosed;
         }
@@ -125406,11 +125482,11 @@ function tokenizeJsxComment(effects, ok, nok) {
             effects.exit('mdxFlowExpressionChunk');
             return before(code);
         }
-        if (code === codes.slash) {
+        if (code === codes_codes.slash) {
             effects.consume(code);
             return expectClosingBrace;
         }
-        if (code === codes.asterisk) {
+        if (code === codes_codes.asterisk) {
             effects.consume(code);
             return maybeClosed;
         }
@@ -125422,7 +125498,7 @@ function tokenizeJsxComment(effects, ok, nok) {
             effects.exit('mdxFlowExpressionChunk');
             return before(code);
         }
-        if (code === codes.rightCurlyBrace) {
+        if (code === codes_codes.rightCurlyBrace) {
             effects.exit('mdxFlowExpressionChunk');
             effects.enter('mdxFlowExpressionMarker');
             effects.consume(code);
@@ -125430,7 +125506,7 @@ function tokenizeJsxComment(effects, ok, nok) {
             effects.exit('mdxFlowExpression');
             return ok;
         }
-        if (code === codes.asterisk) {
+        if (code === codes_codes.asterisk) {
             effects.consume(code);
             return maybeClosed;
         }
@@ -125441,7 +125517,7 @@ function tokenizeJsxComment(effects, ok, nok) {
 function jsxComment() {
     return {
         flow: {
-            [codes.leftCurlyBrace]: {
+            [codes_codes.leftCurlyBrace]: {
                 name: 'jsxComment',
                 concrete: true,
                 tokenize: tokenizeJsxComment,
@@ -125482,7 +125558,7 @@ function tokenizeJsxTable(effects, ok, nok) {
     let codeSpanOpenSize = 0;
     let codeSpanCloseSize = 0;
     let depth = 1;
-    const ABLE_SUFFIX = [codes.lowercaseA, codes.lowercaseB, codes.lowercaseL, codes.lowercaseE];
+    const ABLE_SUFFIX = [codes_codes.lowercaseA, codes_codes.lowercaseB, codes_codes.lowercaseL, codes_codes.lowercaseE];
     /** Build a state chain that matches a sequence of character codes. */
     function matchChars(chars, onMatch, onFail) {
         if (chars.length === 0)
@@ -125497,7 +125573,7 @@ function tokenizeJsxTable(effects, ok, nok) {
     }
     return start;
     function start(code) {
-        if (code !== codes.lessThan)
+        if (code !== codes_codes.lessThan)
             return nok(code);
         effects.enter('jsxTable');
         effects.enter('jsxTableData');
@@ -125505,14 +125581,14 @@ function tokenizeJsxTable(effects, ok, nok) {
         return afterLessThan;
     }
     function afterLessThan(code) {
-        if (code === codes.uppercaseT || code === codes.lowercaseT) {
+        if (code === codes_codes.uppercaseT || code === codes_codes.lowercaseT) {
             effects.consume(code);
             return matchChars(ABLE_SUFFIX, afterTagName, nok);
         }
         return nok(code);
     }
     function afterTagName(code) {
-        if (code === codes.greaterThan || code === codes.slash || code === codes.space || code === codes.horizontalTab) {
+        if (code === codes_codes.greaterThan || code === codes_codes.slash || code === codes_codes.space || code === codes_codes.horizontalTab) {
             effects.consume(code);
             return body;
         }
@@ -125528,17 +125604,17 @@ function tokenizeJsxTable(effects, ok, nok) {
             effects.exit('jsxTableData');
             return continuationStart(code);
         }
-        if (code === codes.backslash) {
+        if (code === codes_codes.backslash) {
             effects.consume(code);
             return escapedChar;
         }
-        if (code === codes.lessThan) {
+        if (code === codes_codes.lessThan) {
             effects.consume(code);
             return closeSlash;
         }
         // Skip over backtick code spans so `</Table>` in inline code isn't
         // treated as the closing tag
-        if (code === codes.graveAccent) {
+        if (code === codes_codes.graveAccent) {
             codeSpanOpenSize = 0;
             return countOpenTicks(code);
         }
@@ -125546,7 +125622,7 @@ function tokenizeJsxTable(effects, ok, nok) {
         return body;
     }
     function countOpenTicks(code) {
-        if (code === codes.graveAccent) {
+        if (code === codes_codes.graveAccent) {
             codeSpanOpenSize += 1;
             effects.consume(code);
             return countOpenTicks;
@@ -125556,7 +125632,7 @@ function tokenizeJsxTable(effects, ok, nok) {
     function inCodeSpan(code) {
         if (code === null || markdownLineEnding(code))
             return body(code);
-        if (code === codes.graveAccent) {
+        if (code === codes_codes.graveAccent) {
             codeSpanCloseSize = 0;
             return countCloseTicks(code);
         }
@@ -125564,7 +125640,7 @@ function tokenizeJsxTable(effects, ok, nok) {
         return inCodeSpan;
     }
     function countCloseTicks(code) {
-        if (code === codes.graveAccent) {
+        if (code === codes_codes.graveAccent) {
             codeSpanCloseSize += 1;
             effects.consume(code);
             return countCloseTicks;
@@ -125579,25 +125655,25 @@ function tokenizeJsxTable(effects, ok, nok) {
         return body;
     }
     function closeSlash(code) {
-        if (code === codes.slash) {
+        if (code === codes_codes.slash) {
             effects.consume(code);
             return closeTagFirstChar;
         }
-        if (code === codes.uppercaseT || code === codes.lowercaseT) {
+        if (code === codes_codes.uppercaseT || code === codes_codes.lowercaseT) {
             effects.consume(code);
             return matchChars(ABLE_SUFFIX, openAfterTagName, body);
         }
         return body(code);
     }
     function closeTagFirstChar(code) {
-        if (code === codes.uppercaseT || code === codes.lowercaseT) {
+        if (code === codes_codes.uppercaseT || code === codes_codes.lowercaseT) {
             effects.consume(code);
             return matchChars(ABLE_SUFFIX, closeGt, body);
         }
         return body(code);
     }
     function openAfterTagName(code) {
-        if (code === codes.greaterThan || code === codes.slash || code === codes.space || code === codes.horizontalTab) {
+        if (code === codes_codes.greaterThan || code === codes_codes.slash || code === codes_codes.space || code === codes_codes.horizontalTab) {
             depth += 1;
             effects.consume(code);
             return body;
@@ -125605,7 +125681,7 @@ function tokenizeJsxTable(effects, ok, nok) {
         return body(code);
     }
     function closeGt(code) {
-        if (code === codes.greaterThan) {
+        if (code === codes_codes.greaterThan) {
             depth -= 1;
             effects.consume(code);
             if (depth === 0) {
@@ -125679,7 +125755,7 @@ function jsx_table_syntax_tokenizeNonLazyContinuationStart(effects, ok, nok) {
 function syntax_jsxTable() {
     return {
         flow: {
-            [codes.lessThan]: [jsxTableConstruct],
+            [codes_codes.lessThan]: [jsxTableConstruct],
         },
     };
 }
@@ -125706,7 +125782,7 @@ function tokenizeTextExpression(effects, ok, nok) {
     let depth = 0;
     return start;
     function start(code) {
-        if (code !== codes.leftCurlyBrace)
+        if (code !== codes_codes.leftCurlyBrace)
             return nok(code);
         effects.enter('mdxTextExpression');
         effects.enter('mdxTextExpressionMarker');
@@ -125715,7 +125791,7 @@ function tokenizeTextExpression(effects, ok, nok) {
         return before;
     }
     function before(code) {
-        if (code === codes.eof) {
+        if (code === codes_codes.eof) {
             effects.exit('mdxTextExpression');
             return nok(code);
         }
@@ -125725,24 +125801,24 @@ function tokenizeTextExpression(effects, ok, nok) {
             effects.exit('lineEnding');
             return before;
         }
-        if (code === codes.rightCurlyBrace && depth === 0) {
+        if (code === codes_codes.rightCurlyBrace && depth === 0) {
             return close(code);
         }
         effects.enter('mdxTextExpressionChunk');
         return inside(code);
     }
     function inside(code) {
-        if (code === codes.eof || markdownLineEnding(code)) {
+        if (code === codes_codes.eof || markdownLineEnding(code)) {
             effects.exit('mdxTextExpressionChunk');
             return before(code);
         }
-        if (code === codes.rightCurlyBrace && depth === 0) {
+        if (code === codes_codes.rightCurlyBrace && depth === 0) {
             effects.exit('mdxTextExpressionChunk');
             return close(code);
         }
-        if (code === codes.leftCurlyBrace)
+        if (code === codes_codes.leftCurlyBrace)
             depth += 1;
-        else if (code === codes.rightCurlyBrace)
+        else if (code === codes_codes.rightCurlyBrace)
             depth -= 1;
         effects.consume(code);
         return inside;
@@ -125758,7 +125834,7 @@ function tokenizeTextExpression(effects, ok, nok) {
 function mdxExpressionLenient() {
     return {
         text: {
-            [codes.leftCurlyBrace]: {
+            [codes_codes.leftCurlyBrace]: {
                 name: 'mdxTextExpression',
                 tokenize: tokenizeTextExpression,
             },
@@ -126472,6 +126548,332 @@ const mdxishTags_tags = (doc) => {
 };
 /* harmony default export */ const mdxishTags = ((/* unused pure expression or super */ null && (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 html_block_component_htmlBlockComponentFromMarkdown() {
+    return {
+        enter: {
+            htmlBlockComponent: enterHtmlBlockComponent,
+        },
+        exit: {
+            htmlBlockComponentData: exitHtmlBlockComponentData,
+            htmlBlockComponent: exitHtmlBlockComponent,
+        },
+    };
+}
+
+;// ./lib/micromark/html-block-component/syntax.ts
+
+
+const TAG_SUFFIX = [
+    codes_codes.uppercaseT,
+    codes_codes.uppercaseM,
+    codes_codes.uppercaseL,
+    codes_codes.uppercaseB,
+    codes_codes.lowercaseL,
+    codes_codes.lowercaseO,
+    codes_codes.lowercaseC,
+    codes_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_codes.uppercaseH) {
+                    effects.consume(code);
+                    return matchChars(TAG_SUFFIX, onMatch, onFail);
+                }
+                return onFail(code);
+            };
+            return next;
+        }
+        return start;
+        function start(code) {
+            if (code !== codes_codes.lessThan)
+                return nok(code);
+            effects.enter('htmlBlockComponent');
+            effects.enter('htmlBlockComponentData');
+            effects.consume(code);
+            return matchTagName(afterTagName, nok);
+        }
+        function afterTagName(code) {
+            if (code === codes_codes.greaterThan) {
+                effects.consume(code);
+                return body;
+            }
+            if (code === codes_codes.space || code === codes_codes.horizontalTab) {
+                effects.consume(code);
+                return inAttributes;
+            }
+            if (mode === 'flow' && markdownLineEnding(code)) {
+                effects.exit('htmlBlockComponentData');
+                return attributeContinuationStart(code);
+            }
+            if (code === codes_codes.slash) {
+                effects.consume(code);
+                return selfClose;
+            }
+            return nok(code);
+        }
+        function inAttributes(code) {
+            if (code === codes_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_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_codes.lessThan) {
+                effects.consume(code);
+                return closeSlash;
+            }
+            effects.consume(code);
+            return body;
+        }
+        function closeSlash(code) {
+            if (code === codes_codes.slash) {
+                effects.consume(code);
+                return matchTagName(closeGt, body);
+            }
+            return matchTagName(openAfterTagName, body)(code);
+        }
+        function openAfterTagName(code) {
+            if (code === codes_codes.greaterThan || code === codes_codes.space || code === codes_codes.horizontalTab) {
+                depth += 1;
+                effects.consume(code);
+                return body;
+            }
+            return body(code);
+        }
+        function closeGt(code) {
+            if (code === codes_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_codes.space || code === codes_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 syntax_htmlBlockComponent() {
+    return {
+        flow: {
+            [codes.lessThan]: [htmlBlockComponentFlowConstruct],
+        },
+        text: {
+            [codes.lessThan]: [htmlBlockComponentTextConstruct],
+        },
+    };
+}
+
+;// ./lib/micromark/html-block-component/index.ts
+
+
 ;// ./lib/stripComments.ts
 
 
@@ -126486,19 +126888,22 @@ const mdxishTags_tags = (doc) => {
 
 
 
+
+
 /**
  * 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