@readme/markdown 15.8.0 → 15.9.1

package/dist/main.node.js

@@ -19045,7 +19045,7 @@ module.exports = function () {
 
 /***/ },
 
-/***/ 4246
+/***/ 6831
 (module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
@@ -75148,18 +75148,53 @@ function evaluate(source, scope = {}) {
     return new Function(...names, `return (${source})`)(...values);
 }
 /**
- * Advance a `Point` by the `consumed` substring that follows it, returning the
- * point at the consumed string's end. Lets split-out sub-nodes carry accurate
- * document positions so downstream offset shifting stays correct.
+ * Width each container prefix adds back per line of `value`, aligned from the line end since a
+ * tab in the prefix is expanded to spaces in `value`. None (a verbatim slice) when the source
+ * is missing or doesn't line up.
  */
-const pointAfter = (start, consumed) => {
-    const newlineIndex = consumed.lastIndexOf('\n');
-    const newlineCount = newlineIndex === -1 ? 0 : consumed.split('\n').length - 1;
-    return {
-        line: start.line + newlineCount,
-        // Same line → advance the base column; a later line → column is the run since its newline.
-        column: newlineCount === 0 ? start.column + consumed.length : consumed.length - newlineIndex,
-        offset: (start.offset ?? 0) + consumed.length,
+const containerPrefixWidths = (valueLines, source, position) => {
+    const sourceLines = source?.slice(position.start.offset, position.end.offset).split('\n');
+    const linesUp = sourceLines?.length === valueLines.length &&
+        sourceLines.every((line, i) => line.endsWith(valueLines[i].trimStart()));
+    return valueLines.map((line, i) => (linesUp ? sourceLines[i].length - line.length : 0));
+};
+/**
+ * Maps offsets in a node's `value` to points in `source`. Containers strip a prefix from every
+ * continuation line of `value`, so a plain offset shift drifts by line (CX-4028).
+ */
+const createValueToSourceMapper = (position, value, source) => {
+    if (position?.start.offset === undefined)
+        return null;
+    const { start } = position;
+    const valueLines = value.split('\n');
+    const prefixWidths = containerPrefixWidths(valueLines, source, position);
+    const lines = [];
+    let valueStart = 0;
+    let sourceStart = start.offset;
+    valueLines.forEach((line, i) => {
+        lines.push({ prefixWidth: prefixWidths[i], sourceStart, valueStart });
+        valueStart += line.length + 1;
+        sourceStart += prefixWidths[i] + line.length + 1;
+    });
+    return valueOffset => {
+        // Binary search: a large table maps one point per node.
+        let low = 0;
+        let high = lines.length - 1;
+        while (low < high) {
+            const mid = Math.ceil((low + high) / 2);
+            if (lines[mid].valueStart <= valueOffset)
+                low = mid;
+            else
+                high = mid - 1;
+        }
+        const { prefixWidth, sourceStart: lineSourceStart, valueStart: lineValueStart } = lines[low];
+        // Clamped: an expanded tab can make a leading-whitespace offset fall before the line.
+        const sourceColumn = Math.max(0, prefixWidth + valueOffset - lineValueStart);
+        return {
+            line: start.line + low,
+            column: (low === 0 ? start.column : 1) + sourceColumn,
+            offset: lineSourceStart + sourceColumn,
+        };
     };
 };
 /**
@@ -75822,7 +75857,9 @@ const processBlockquote = (node, index, parent, isMdxish = false) => {
         }
         Object.assign(node, {
             type: NodeTypes.callout,
+            // Keep the blockquote's data, e.g. the `reparseSource` its positions index into.
             data: {
+                ...node.data,
                 hName: 'Callout',
                 hProperties: {
                     icon,
@@ -75855,14 +75892,55 @@ const calloutTransformer = ({ isMdxish = false } = {}) => {
 };
 /* harmony default export */ const callouts = (calloutTransformer);
 
+;// ./processor/transform/mdxish/reparse-source.ts
+/**
+ * Mark re-parsed subtree roots with the string their positions index into, so consumers
+ * slicing by offset use the right source (see `Data.reparseSource`). Only roots are
+ * stamped; descendants resolve via their nearest stamped ancestor. Roots a deeper
+ * re-parse already stamped keep their own string.
+ */
+const stampReparseSource = (roots, reparseSource) => {
+    roots.forEach(root => {
+        if (!root.data?.reparseSource)
+            root.data = { ...root.data, reparseSource };
+    });
+};
+/**
+ * Splice `replacements` over `parent.children[index]`. They take over the replaced node's
+ * position, so they also take over the coordinate space that position indexes into.
+ */
+const replaceInheritingReparseSource = (parent, index, replacements) => {
+    const replacedSource = parent.children[index]?.data?.reparseSource;
+    if (replacedSource)
+        stampReparseSource(replacements, replacedSource);
+    parent.children.splice(index, 1, ...replacements);
+};
+/**
+ * The string `node`'s offsets index into: the nearest stamp on it or an ancestor, else the
+ * document source.
+ */
+const resolveReparseSource = (node, ancestors, documentSource) => {
+    if (node.data?.reparseSource)
+        return node.data.reparseSource;
+    for (let i = ancestors.length - 1; i >= 0; i -= 1) {
+        const { reparseSource } = ancestors[i].data ?? {};
+        if (reparseSource)
+            return reparseSource;
+    }
+    return documentSource;
+};
+
 ;// ./processor/transform/code-tabs.ts
 
 
+
 const isCode = (node) => node?.type === 'code';
 const codeTabsTransformer = ({ copyButtons } = {}) => (tree) => {
     visit(tree, 'code', (node) => {
         const { lang, meta, value } = node;
         node.data = {
+            // Ensure positions are passed through
+            ...node.data,
             hProperties: { lang, meta, value, copyButtons },
         };
     });
@@ -75909,6 +75987,9 @@ const codeTabsTransformer = ({ copyButtons } = {}) => (tree) => {
                 end: children[children.length - 1].position.end,
             },
         };
+        // Adjacent siblings share a coordinate space, so the wrapper takes the first block's.
+        if (node.data?.reparseSource)
+            stampReparseSource([codeTabs], node.data.reparseSource);
         parent.children.splice(index, children.length, codeTabs);
     });
     return tree;
@@ -100291,6 +100372,7 @@ const walkTags = (html, handlers) => {
 };
 
 ;// ./processor/transform/mdxish/tables/utils.ts
+
 const tableTags = new Set([
     'thead',
     'tbody',
@@ -100309,6 +100391,9 @@ const tableTags = new Set([
 const unwrapParagraphNodes = (children) => {
     return children.flatMap(child => {
         if (child.type === 'paragraph' && 'children' in child && Array.isArray(child.children)) {
+            // The unwrap drops a stamped root, so its children inherit that coordinate space.
+            if (child.data?.reparseSource)
+                stampReparseSource(child.children, child.data.reparseSource);
             return child.children;
         }
         return [child];
@@ -100904,9 +100989,10 @@ const findTableRanges = (html) => {
  * The surrounding raw HTML (the wrapper's open/close tags) would be re-nested
  * around the parsed tables by rehype-raw.
  *
- * Returns null when there is no wrapped table to extract.
+ * Returns null when there is no wrapped table to extract. `source` is the string the node's
+ * positions index into, so the parts' positions survive stripped container prefixes.
  */
-const splitHtmlWithNestedTables = (node) => {
+const splitHtmlWithNestedTables = (node, source) => {
     const { value } = node;
     // This is a top-level table, so we don't need to split it
     if (TOP_LEVEL_TABLE_TAG_RE.test(value))
@@ -100919,13 +101005,11 @@ const splitHtmlWithNestedTables = (node) => {
     const ranges = findTableRanges(value);
     if (ranges.length === 0)
         return null;
-    const base = node.position?.start;
+    const toSourcePoint = createValueToSourceMapper(node.position, value, source);
     const sliceToHtml = (from, to) => ({
         type: 'html',
         value: value.slice(from, to),
-        ...(base && {
-            position: { start: pointAfter(base, value.slice(0, from)), end: pointAfter(base, value.slice(0, to)) },
-        }),
+        ...(toSourcePoint && { position: { start: toSourcePoint(from), end: toSourcePoint(to) } }),
     });
     const parts = [];
     let cursor = 0;
@@ -100960,6 +101044,8 @@ const splitHtmlWithNestedTables = (node) => {
 
 
 
+
+
 
 
 
@@ -101012,7 +101098,7 @@ const tableRepairs = [
  * The plugins in the processor allows parsing markdown & special syntax inside the table cells
  * After parsing, we need to update the node positions
  */
-const parseTableNode = (processor, node, repair) => {
+const parseTableNode = (processor, node, source, repair) => {
     let parsed;
     try {
         parsed = processor.runSync(processor.parse(node.value));
@@ -101026,19 +101112,18 @@ const parseTableNode = (processor, node, repair) => {
     if (repair) {
         remapPositionsThroughLayers(parsed, repair.originalSource, repair.layers);
     }
-    // The subparser produces positions relative to `node.value`; shift them by
-    // the outer node's offset/line so consumers can slice the full source.
-    const baseOffset = node.position?.start?.offset ?? 0;
-    const baseLine = (node.position?.start?.line ?? 1) - 1;
+    // The subparser produces positions relative to `node.value`; map them into
+    // the outer source so consumers can slice it.
+    const toSourcePoint = createValueToSourceMapper(node.position, repair?.originalSource ?? node.value, source);
+    if (!toSourcePoint)
+        return parsed;
     visit(parsed, child => {
-        if (child.position?.start) {
-            child.position.start.offset = (child.position.start.offset ?? 0) + baseOffset;
-            child.position.start.line += baseLine;
-        }
-        if (child.position?.end) {
-            child.position.end.offset = (child.position.end.offset ?? 0) + baseOffset;
-            child.position.end.line += baseLine;
-        }
+        if (!child.position)
+            return;
+        child.position = {
+            start: toSourcePoint(child.position.start.offset ?? 0),
+            end: toSourcePoint(child.position.end.offset ?? 0),
+        };
     });
     return parsed;
 };
@@ -101068,12 +101153,10 @@ const hasFlowContent = (nodes) => {
     return nodes.some(node => !phrasing(node) && node.type !== 'paragraph');
 };
 /**
- * Process a Table node: re-parse text-only cell content, then output as
- * a markdown table (phrasing-only) or keep as JSX <Table> (has flow content).
+ * Process a Table node: re-parse text-only cell content, then return it as
+ * a markdown table (phrasing-only) or keep it as JSX <Table> (has flow content).
  */
-const processTableNode = (node, index, parent, documentPosition) => {
-    if (node.name !== 'Table' && node.name !== 'table')
-        return;
+const processTableNode = (node, documentPosition) => {
     const position = documentPosition ?? node.position;
     const { align: alignAttr } = getAttrs(node);
     const align = Array.isArray(alignAttr) ? alignAttr : null;
@@ -101100,6 +101183,8 @@ const processTableNode = (node, index, parent, documentPosition) => {
         try {
             const parsed = tableNodeProcessor.runSync(tableNodeProcessor.parse(textContent));
             if (parsed.children.length > 0) {
+                // Positions index into the extracted text rather than the table source (CX-4004).
+                stampReparseSource(parsed.children, textContent);
                 cell.children = parsed.children;
                 if (hasFlowContent(parsed.children)) {
                     tableHasFlowContent = true;
@@ -101142,11 +101227,7 @@ const processTableNode = (node, index, parent, documentPosition) => {
                 : unwrapParagraphNodes(el.children);
             el.children = removeWhitespaceOnlyTextNodes(unwrapped);
         });
-        parent.children[index] = {
-            ...node,
-            position,
-        };
-        return;
+        return { ...node, position };
     }
     // All cells are phrasing-only — convert to markdown table
     const children = [];
@@ -101224,7 +101305,7 @@ const processTableNode = (node, index, parent, documentPosition) => {
     const alignArray = align && columnCount > 0
         ? align.slice(0, columnCount).concat(new Array(Math.max(0, columnCount - align.length)).fill(null))
         : new Array(columnCount).fill(null);
-    const mdNode = {
+    return {
         align: alignArray,
         type: 'table',
         position,
@@ -101232,14 +101313,13 @@ const processTableNode = (node, index, parent, documentPosition) => {
         // Remember the author's spelling so the serializer can write `<table>` back instead of `<Table>`
         ...(node.name === 'table' && { data: { lowercaseTable: true } }),
     };
-    parent.children[index] = mdNode;
 };
 /**
  * Apply `tableRepairs` cumulatively, re-parsing after every change and stopping
  * once the accumulated result parses. Each layer's inserts are relative to the
  * string that repair received, so they stay ordered for position remapping.
  */
-const repairAndReparse = (node) => {
+const repairAndReparse = (node, source) => {
     let repairedValue = node.value;
     const layers = [];
     let parsed;
@@ -101249,11 +101329,45 @@ const repairAndReparse = (node) => {
             return false;
         repairedValue = value;
         layers.push(inserts);
-        parsed = parseTableNode(tableNodeProcessor, { ...node, value: repairedValue }, { layers, originalSource: node.value });
+        parsed = parseTableNode(tableNodeProcessor, { ...node, value: repairedValue }, source, {
+            layers,
+            originalSource: node.value,
+        });
         return Boolean(parsed);
     });
     return parsed;
 };
+/**
+ * Re-parse a table html node and replace it with a markdown / JSX table, or the
+ * fallback parse's fragments for a lowercase table mdxjs rejects.
+ */
+const replaceTableHtml = (node, index, parent, source) => {
+    // Because the processor uses remarkMdx, it is stricter in what it accepts
+    // and only accepts valid MDX syntax in the table node. To get around that,
+    // fall back to the cumulative repairs when the first parse fails.
+    const parsed = parseTableNode(tableNodeProcessor, node, source) ?? repairAndReparse(node, source);
+    if (parsed) {
+        // If the table is parsed successfully, we can now process it further
+        // to build on the markdown / JSX table
+        visit(parsed, isMDXElement, (tableNode) => {
+            if (tableNode.name !== 'Table' && tableNode.name !== 'table')
+                return undefined;
+            replaceInheritingReparseSource(parent, index, [processTableNode(tableNode, node.position)]);
+            return (/* inlined export .EXIT */false);
+        });
+    }
+    else if (node.value.startsWith('<table')) {
+        // If the parsing still fails, give an opportunity to the fallback parser
+        // without remarkMdx to process lowercase tables as it's likely to not
+        // have needed MDX parsing anyway
+        const fallback = parseTableNode(fallbackTableNodeProcessor, node, source);
+        if (!fallback || fallback.children.length <= 1)
+            return;
+        replaceInheritingReparseSource(parent, index, fallback.children);
+    }
+    // Otherwise, there's no point in trying to parse the table content further
+    // More repairs are needed in that case
+};
 /**
  * Converts JSX Table elements to markdown table nodes and re-parses markdown in cells.
  *
@@ -101265,24 +101379,26 @@ const repairAndReparse = (node) => {
  * When cell content contains block-level nodes (callouts, code blocks, etc.), the table
  * is kept as a JSX <Table> element so that remarkRehype can properly handle the flow content.
  */
-const mdxishTables = () => tree => {
+const mdxishTables = () => (tree, file) => {
+    // Positions index into the document unless a re-parse stamped another source.
+    const documentSource = file?.value ? String(file.value) : undefined;
     // Pre-pass: lift `<table>`s wrapped in a raw HTML block out into their own
     // html nodes so the main pass below treats them like top-level tables.
-    visit(tree, 'html', (_node, index, parent) => {
-        const node = _node;
-        if (typeof index !== 'number' || !parent || !('children' in parent))
+    visitParents(tree, 'html', (node, ancestors) => {
+        const parent = ancestors[ancestors.length - 1];
+        if (!parent)
             return;
-        const parts = splitHtmlWithNestedTables(node);
+        const parts = splitHtmlWithNestedTables(node, resolveReparseSource(node, ancestors, documentSource));
         if (!parts)
             return;
         // The inserted parts can't re-trigger a split (table parts start with
         // `<table`; the wrapper slices hold no table), so plain in-place splicing
         // visits each once without looping.
-        parent.children.splice(index, 1, ...parts);
+        replaceInheritingReparseSource(parent, parent.children.indexOf(node), parts);
     });
-    visit(tree, 'html', (_node, index, parent) => {
-        const node = _node;
-        if (typeof index !== 'number' || !parent || !('children' in parent))
+    visitParents(tree, 'html', (node, ancestors) => {
+        const parent = ancestors[ancestors.length - 1];
+        if (!parent)
             return;
         if (!node.value.startsWith('<Table') && !node.value.startsWith('<table'))
             return;
@@ -101290,33 +101406,8 @@ const mdxishTables = () => tree => {
         // paragraph. Leave them untouched so rehype-raw can reassemble the table.
         if (parent.type === 'paragraph')
             return;
-        // Because the processor uses remarkMdx, it is stricter in what it accepts
-        // and only accepts valid MDX syntax in the table node. To get around that,
-        // fall back to the cumulative repairs when the first parse fails.
-        const parsed = parseTableNode(tableNodeProcessor, node) ?? repairAndReparse(node);
-        if (parsed) {
-            // If the table is parsed successfully, we can now process it further
-            // to build on the markdown / JSX table
-            visit(parsed, isMDXElement, (tableNode) => {
-                if (tableNode.name !== 'Table' && tableNode.name !== 'table')
-                    return undefined;
-                processTableNode(tableNode, index, parent, node.position);
-                return (/* inlined export .EXIT */false);
-            });
-        }
-        else if (node.value.startsWith('<table')) {
-            // If the parsing still fails, give an opportunity to the fallback parser
-            // without remarkMdx to process lowercase tables as it's likely to not
-            // have needed MDX parsing anyway
-            const fallback = parseTableNode(fallbackTableNodeProcessor, node);
-            if (!fallback || fallback.children.length <= 1)
-                return;
-            parent.children.splice(index, 1, ...fallback.children);
-        }
-        // Otherwise, there's no point in trying to parse the table content further
-        // More repairs are needed in that case
+        replaceTableHtml(node, parent.children.indexOf(node), parent, resolveReparseSource(node, ancestors, documentSource));
     });
-    return tree;
 };
 /* harmony default export */ const mdxish_tables = (mdxishTables);
 
@@ -124124,9 +124215,9 @@ const mdxishCalloutToJsx = () => tree => {
     visit(tree, NodeTypes.callout, (node, index, parent) => {
         if (!parent || index === undefined)
             return;
-        let { icon, theme } = node.data.hProperties;
-        if (!icon && theme)
-            icon = defaultIcons[theme];
+        // No default-icon fill: an empty `icon` means the author removed it
+        const { icon } = node.data.hProperties;
+        let { theme } = node.data.hProperties;
         if (!theme && icon)
             theme = themes[icon] || 'default';
         // Mutate in place to keep the children array identity so nested callouts in
@@ -124677,18 +124768,6 @@ const getInlineMdProcessor = ({ safeMode = false } = {}) => {
     }
     return processor;
 };
-/**
- * Mark re-parsed subtree roots with the string their positions index into, so consumers
- * slicing by offset use the right source (see `Data.reparseSource`). Only roots are
- * stamped; descendants resolve via their nearest stamped ancestor. Roots a deeper
- * re-parse already stamped keep their own string.
- */
-const stampReparseSource = (roots, reparseSource) => {
-    roots.forEach(root => {
-        if (!root.data?.reparseSource)
-            root.data = { ...root.data, reparseSource };
-    });
-};
 /**
  * True when a tag name starts with an uppercase letter — ReadMe's marker for
  * a custom MDX component (vs a lowercase HTML tag).
@@ -124775,6 +124854,7 @@ function findBalancedClosingTagIndex(content, tag) {
 
 
 
+
 /**
  * Parse the body of an inline component as phrasing content. Remark always
  * wraps bare text in a paragraph; flatten that single-paragraph wrapper so
@@ -125026,6 +125106,7 @@ function terminateHtmlFlowBlocks(content) {
 
 
 
+
 // Matches a JSX attribute expression (e.g. `key={i}`) anywhere in a string. One name
 // char suffices for existence — `[\w-]+` backtracked quadratically over huge attributes.
 const NESTED_ATTR_EXPRESSION_RE = /[\w-]\s*=\s*\{/;
@@ -125107,26 +125188,12 @@ const parseSibling = (parent, index, sibling, safeMode, promoted) => {
     }
 };
 // Ends the position at `consumedLength` so the component doesn't claim trailing
-// content the tokenizer swallowed into the same html node. Measured against the source
-// when available: each value line is its source line minus the container prefix
-// (list indent, `> `) micromark stripped, so those prefixes are counted back in.
+// content the tokenizer swallowed into the same html node.
 const positionEndingAtConsumed = (nodePosition, value, consumedLength, source) => {
-    if (!nodePosition?.start)
+    const toSourcePoint = createValueToSourceMapper(nodePosition, value, source);
+    if (!nodePosition || !toSourcePoint)
         return nodePosition;
-    const consumedValue = value.slice(0, consumedLength);
-    const sourceLines = source?.slice(nodePosition.start.offset, nodePosition.end?.offset).split('\n');
-    const valueLines = value.split('\n');
-    if (!sourceLines || sourceLines.length !== valueLines.length) {
-        return { start: nodePosition.start, end: pointAfter(nodePosition.start, consumedValue) };
-    }
-    const consumedLines = consumedValue.split('\n');
-    const lastLineIndex = consumedLines.length - 1;
-    const prefixWidth = sourceLines[lastLineIndex].length - valueLines[lastLineIndex].length;
-    const consumedSource = [
-        ...sourceLines.slice(0, lastLineIndex),
-        sourceLines[lastLineIndex].slice(0, prefixWidth + consumedLines[lastLineIndex].length),
-    ].join('\n');
-    return { start: nodePosition.start, end: pointAfter(nodePosition.start, consumedSource) };
+    return { start: nodePosition.start, end: toSourcePoint(consumedLength) };
 };
 const createComponentNode = ({ tag, attributes, children, startPosition, endPosition, }) => ({
     type: 'mdxJsxFlowElement',
@@ -125138,14 +125205,6 @@ const createComponentNode = ({ tag, attributes, children, startPosition, endPosi
         end: endPosition?.end ?? startPosition?.end,
     },
 });
-// The promoted node takes over the html node's position, so it also takes over the
-// coordinate space that position belongs to.
-const substituteNodeWithMdxNode = (parent, index, mdxNode) => {
-    const replacedSource = parent.children[index]?.data?.reparseSource;
-    if (replacedSource)
-        stampReparseSource([mdxNode], replacedSource);
-    parent.children.splice(index, 1, mdxNode);
-};
 /**
  * Transform PascalCase HTML nodes into mdxJsxFlowElement nodes.
  *
@@ -125244,7 +125303,7 @@ function promoteComponentBlocks(tree, safeMode, source) {
                     ? positionEndingAtConsumed(node.position, value, leadingWhitespace + openingTagEnd, source)
                     : node.position,
             });
-            substituteNodeWithMdxNode(parent, index, componentNode);
+            replaceInheritingReparseSource(parent, index, [componentNode]);
             if (remainingContent) {
                 parseSibling(parent, index, remainingContent, safeMode, promoted);
             }
@@ -125295,7 +125354,7 @@ function promoteComponentBlocks(tree, safeMode, source) {
                 startPosition: node.position,
                 endPosition,
             });
-            substituteNodeWithMdxNode(parent, index, componentNode);
+            replaceInheritingReparseSource(parent, index, [componentNode]);
             // The unwrap reparented the children out of their paragraph, so re-walk them
             // since the children HTML may contain promotable syntax (e.g. `{…}`-attr tags)
             if (unwrappedSoleParagraph) {
@@ -126737,6 +126796,7 @@ const magicBlockTransformer = (options = {}) => tree => {
 
 
 
+
 // `<HTMLBlock …>{`…`}</HTMLBlock>` embedded inside a raw HTML block (e.g. a
 // single-line `<div>…</div>`). CommonMark slurps the whole div as one `html`
 // node, so the tokenizer never sees the HTMLBlock — we recover it here.
@@ -126843,7 +126903,8 @@ const mdxishHtmlBlocks = () => tree => {
             return;
         const exprChild = element.children.find(child => child.type === 'mdxFlowExpression' || child.type === 'mdxTextExpression');
         const openingTagIndent = (element.position?.start.column ?? 1) - 1;
-        parent.children[index] = createHtmlBlockNode(formatHtmlForMdxish(extractTemplateLiteral(exprChild?.value), openingTagIndent), element.position, toRunScripts(jsxAttr(element, 'runScripts')), jsxAttr(element, 'safeMode'));
+        const htmlBlock = createHtmlBlockNode(formatHtmlForMdxish(extractTemplateLiteral(exprChild?.value), openingTagIndent), element.position, toRunScripts(jsxAttr(element, 'runScripts')), jsxAttr(element, 'safeMode'));
+        replaceInheritingReparseSource(parent, index, [htmlBlock]);
     });
     // Shape 2: raw HTML blob.
     visit(tree, 'html', (node, index, parent) => {
@@ -126851,11 +126912,85 @@ const mdxishHtmlBlocks = () => tree => {
             return;
         const replacement = splitRawHtmlBlocks(node);
         if (replacement)
-            parent.children.splice(index, 1, ...replacement);
+            replaceInheritingReparseSource(parent, index, replacement);
     });
 };
 /* harmony default export */ const mdxish_html_blocks = (mdxishHtmlBlocks);
 
+;// ./processor/transform/mdxish/tables/cell-width.ts
+
+
+// Key must follow `{` or `,` so `minWidth`/`maxWidth` don't match on their suffix
+const STYLE_OBJECT_WIDTH_REGEX = /[{,]\s*["']?width["']?\s*:\s*(?:"([^"]*)"|'([^']*)'|([^,}]+))/i;
+// First colon only, so `url(http://…)` values stay intact
+const CSS_DECLARATION_REGEX = /:(.*)/s;
+const UNITLESS_NUMBER_REGEX = /^\d+(?:\.\d+)?$/;
+// HTML reads a `width` attribute as a leading number plus optional `%`, ignoring the rest
+const HTML_DIMENSION_REGEX = /^\s*(\d+(?:\.\d+)?)\s*(%?)/;
+/** Bare numbers are pixels. A value carrying declaration separators is not a single width. */
+const normalizeWidth = (value) => {
+    if (typeof value === 'number')
+        return `${value}px`;
+    if (typeof value !== 'string' || !value.trim())
+        return null;
+    const trimmed = value.trim();
+    if (/[;:{}]/.test(trimmed))
+        return null;
+    return UNITLESS_NUMBER_REGEX.test(trimmed) ? `${trimmed}px` : trimmed;
+};
+const widthFromAttribute = (value) => {
+    if (typeof value === 'number')
+        return `${value}px`;
+    if (typeof value !== 'string')
+        return null;
+    const match = HTML_DIMENSION_REGEX.exec(value);
+    return match ? `${match[1]}${match[2] || 'px'}` : null;
+};
+const cssPropertyNames = (style) => style
+    .split(';')
+    .map(declaration => declaration.split(CSS_DECLARATION_REGEX)[0].trim().toLowerCase())
+    .filter(Boolean);
+/** Handles a CSS declaration list and a style object safe mode left as a string (`{ width: "30%" }`). */
+const widthFromStyleString = (style) => {
+    const trimmed = style.trim();
+    if (trimmed.startsWith('{')) {
+        return STYLE_OBJECT_WIDTH_REGEX.exec(trimmed)?.slice(1).find(Boolean);
+    }
+    return trimmed
+        .split(';')
+        .map(declaration => declaration.split(CSS_DECLARATION_REGEX))
+        .find(([property]) => property.trim().toLowerCase() === 'width')?.[1];
+};
+/** Accepts `style={{ width }}`, `style="width: …"` and the hand-authored `width="…"`. */
+const getCellWidth = (cell) => {
+    const { style, width } = getAttrs(cell);
+    let styleWidth;
+    if (style_object_to_css_isPlainObject(style)) {
+        styleWidth = style.width;
+    }
+    else if (typeof style === 'string') {
+        styleWidth = widthFromStyleString(style);
+    }
+    return normalizeWidth(styleWidth) ?? widthFromAttribute(width);
+};
+/** True when the cell's attributes state nothing but its width, which mdast can carry. */
+const hasOnlyWidthAttributes = (cell) => {
+    if (cell.attributes.length === 0)
+        return false;
+    const { style } = getAttrs(cell);
+    return cell.attributes.every(attribute => {
+        if (!('name' in attribute))
+            return false;
+        if (attribute.name === 'width')
+            return true;
+        if (attribute.name !== 'style')
+            return false;
+        if (style_object_to_css_isPlainObject(style))
+            return Object.keys(style).every(key => key === 'width');
+        return typeof style === 'string' && cssPropertyNames(style).every(property => property === 'width');
+    });
+};
+
 ;// ./processor/transform/mdxish/mdxish-jsx-to-mdast.ts
 
 
@@ -126863,6 +126998,8 @@ const mdxishHtmlBlocks = () => tree => {
 
 
 
+
+
 function toImageAlign(value) {
     if (value === 'left' || value === 'center' || value === 'right') {
         return value;
@@ -127078,6 +127215,15 @@ const transformAnchor = (jsx) => {
         position: jsx.position,
     };
 };
+/**
+ * Parses an image caption's markdown. The caption is re-parsed on its own, so the
+ * children's positions index into it rather than the document.
+ */
+const parseCaptionChildren = (caption) => {
+    const { children } = lib_mdast(caption);
+    stampReparseSource(children, caption);
+    return children;
+};
 /**
  * Transforms an `<Image />` JSX element into an image-block MDAST node.
  * Normalizes attributes (align, border, width→sizing) and parses caption markdown into children.
@@ -127108,7 +127254,7 @@ const transformImage = (jsx) => {
         alt,
         border: toBool(border),
         caption,
-        children: caption ? lib_mdast(caption).children : [],
+        children: caption ? parseCaptionChildren(caption) : [],
         className,
         framed: toBool(framed),
         height: height !== undefined ? String(height) : undefined,
@@ -127304,10 +127450,40 @@ const wrapBareCellsInRow = (node) => {
     });
 };
 /**
- * Converts a JSX <Table> element to an MDAST table node with alignment.
- * Returns null for header-less tables since MDAST always promotes the first row to <thead>.
+ * A lowercase <table> reaches here only because `mdxishTables` kept it as JSX for its
+ * attributes. Widths on first-row cells are the one attribute mdast can carry; anything
+ * else stays JSX so it still renders.
+ */
+const lowercaseTableIsConvertible = (jsx) => {
+    if (jsx.attributes.length > 0)
+        return false;
+    const headerCells = new Set();
+    let headerRowSeen = false;
+    let convertible = true;
+    visit(jsx, isMDXElement, (child) => {
+        if (child.name === 'tr' && !headerRowSeen) {
+            headerRowSeen = true;
+            visit(child, mdxish_jsx_to_mdast_isTableCell, cell => {
+                headerCells.add(cell);
+            });
+        }
+        if (child.name === null || !tableTags.has(child.name) || child.attributes.length === 0)
+            return;
+        if (!headerCells.has(child) || !hasOnlyWidthAttributes(child) || getCellWidth(child) === null) {
+            convertible = false;
+        }
+    });
+    return convertible;
+};
+/**
+ * Converts a JSX <Table>, or a lowercase <table> carrying only widths, to an MDAST table
+ * node with alignment and widths. Returns null for header-less tables since MDAST always
+ * promotes the first row to <thead>.
  */
 const transformTable = (jsx) => {
+    const isLowercase = jsx.name === 'table';
+    if (isLowercase && !lowercaseTableIsConvertible(jsx))
+        return null;
     wrapBareCellsInRow(jsx);
     let hasThead = false;
     visit(jsx, isMDXElement, (child) => {
@@ -127319,6 +127495,7 @@ const transformTable = (jsx) => {
     const { align: alignAttr } = getAttrs(jsx);
     const align = Array.isArray(alignAttr) ? alignAttr : null;
     const rows = [];
+    const widths = [];
     visit(jsx, isMDXElement, (child) => {
         if (child.name !== 'thead' && child.name !== 'tbody')
             return;
@@ -127326,6 +127503,7 @@ const transformTable = (jsx) => {
             if (row.name !== 'tr')
                 return;
             const cells = [];
+            const isHeaderRow = rows.length === 0;
             visit(row, mdxish_jsx_to_mdast_isTableCell, (cell) => {
                 const parsedChildren = unwrapSoleParagraph(cell.children);
                 cells.push({
@@ -127333,6 +127511,8 @@ const transformTable = (jsx) => {
                     children: parsedChildren,
                     position: cell.position,
                 });
+                if (isHeaderRow)
+                    widths.push(getCellWidth(cell));
             });
             rows.push({
                 type: 'tableRow',
@@ -127345,11 +127525,16 @@ const transformTable = (jsx) => {
     const alignArray = align && columnCount > 0
         ? align.slice(0, columnCount).concat(Array.from({ length: Math.max(0, columnCount - align.length) }, () => null))
         : Array.from({ length: columnCount }, () => null);
+    const data = {
+        ...(isLowercase && { lowercaseTable: true }),
+        ...(widths.some(Boolean) && { widths }),
+    };
     return {
         type: 'table',
         align: alignArray,
         position: jsx.position,
         children: rows,
+        ...(Object.keys(data).length > 0 && { data }),
     };
 };
 /**
@@ -127379,6 +127564,7 @@ const COMPONENT_MAP = {
     figure: transformFigure,
     Recipe: transformRecipe,
     Table: transformTable,
+    table: transformTable,
 };
 /**
  * Transform mdxJsxFlowElement nodes, magic block nodes, and HTML figure elements
@@ -127405,8 +127591,7 @@ const mdxishJsxToMdast = () => tree => {
         const newNode = transformer(node);
         if (!newNode)
             return;
-        // Replace the JSX node with the MDAST node
-        parent.children[index] = newNode;
+        replaceInheritingReparseSource(parent, index, [newNode]);
     });
     // Inline JSX components (Anchor)
     visit(tree, 'mdxJsxTextElement', (node, index, parent) => {
@@ -127854,6 +128039,28 @@ const restoreBooleanProperties = () => tree => {
 };
 
 
+;// ./processor/transform/mdxish/tables/cell-style.ts
+/** `left` is the browser default, so it's omitted. Lowercase tables get the HTML string form. */
+const cellStyle = (align, width = null, { html = false } = {}) => {
+    if (html) {
+        if (!width)
+            return null;
+        return { type: 'mdxJsxAttribute', name: 'style', value: `width: ${width}` };
+    }
+    const declarations = [];
+    if (align && align !== 'left')
+        declarations.push(`textAlign: ${JSON.stringify(align)}`);
+    if (width)
+        declarations.push(`width: ${JSON.stringify(width)}`);
+    if (declarations.length === 0)
+        return null;
+    return {
+        type: 'mdxJsxAttribute',
+        name: 'style',
+        value: { type: 'mdxJsxAttributeValueExpression', value: `{ ${declarations.join(', ')} }` },
+    };
+};
+
 ;// ./processor/transform/mdxish/tables/gfm-cell-normalization.ts
 /** `<br />` is the only line break a GFM pipe cell can carry, since cells are single-line. */
 const createLineBreak = () => ({
@@ -127892,19 +128099,8 @@ const normalizeCellChildrenForGfm = (cell) => normalizeNodes(cell.children);
 
 
 
+
 const SELF_CLOSING_JSX_REGEX = /^\s*<[A-Z][^>]*\/>\s*$/;
-const mdxish_tables_to_jsx_alignToStyle = (align) => {
-    if (!align || align === 'left')
-        return null;
-    return {
-        type: 'mdxJsxAttribute',
-        name: 'style',
-        value: {
-            type: 'mdxJsxAttributeValueExpression',
-            value: `{ textAlign: "${align}" }`,
-        },
-    };
-};
 const mdxish_tables_to_jsx_isTableCell = (node) => ['tableHead', 'tableCell'].includes(node.type);
 const mdxish_tables_to_jsx_isLiteral = (node) => 'value' in node;
 /**
@@ -127960,12 +128156,17 @@ const mdxishTablesToJsx = () => tree => {
             gfmCells.push([cell, normalized]);
             return undefined;
         });
-        const stayLowercase = table.data?.lowercaseTable === true;
+        const widths = table.data?.widths ?? [];
+        const hasWidths = widths.some(Boolean);
+        // Lowercase cells can carry a width but not an alignment, so an aligned table becomes <Table>
+        const hasAlignment = table.align.some(align => align && align !== 'left');
+        const stayLowercase = table.data?.lowercaseTable === true && !hasAlignment;
         // We transform to GFM tables if:
         // 1. If it doesn't contain complex elements that the syntax can't represent
-        // 2. The original table is not lowercase HTML <table>, because we want to 
+        // 2. The original table is not lowercase HTML <table>, because we want to
         // preserve original tables as much as possible
-        if (!requiresJsxTable && !stayLowercase) {
+        // 3. No column has a width, which GFM can't express
+        if (!requiresJsxTable && !stayLowercase && !hasWidths) {
             gfmCells.forEach(([cell, children]) => {
                 cell.children = children;
             });
@@ -127977,7 +128178,8 @@ const mdxishTablesToJsx = () => tree => {
         if (!headerRow)
             return;
         visit(table, mdxish_tables_to_jsx_isTableCell, flattenBreaksToNewlines);
-        const styles = table.align.map(mdxish_tables_to_jsx_alignToStyle);
+        const headerStyles = table.align.map((align, i) => cellStyle(align, widths[i] ?? null, { html: stayLowercase }));
+        const bodyStyles = table.align.map(align => cellStyle(align, null, { html: stayLowercase }));
         const head = {
             attributes: [],
             type: 'mdxJsxFlowElement',
@@ -127993,7 +128195,7 @@ const mdxishTablesToJsx = () => tree => {
                             type: 'mdxJsxFlowElement',
                             name: 'th',
                             children: cell.children,
-                            ...(styles[cellIndex] && { attributes: [styles[cellIndex]] }),
+                            ...(headerStyles[cellIndex] && { attributes: [headerStyles[cellIndex]] }),
                         };
                     }),
                 },
@@ -128013,7 +128215,7 @@ const mdxishTablesToJsx = () => tree => {
                             type: 'mdxJsxFlowElement',
                             name: 'td',
                             children: cell.children,
-                            ...(styles[cellIndex] && { attributes: [styles[cellIndex]] }),
+                            ...(bodyStyles[cellIndex] && { attributes: [bodyStyles[cellIndex]] }),
                         };
                     }),
                 };
@@ -129485,7 +129687,7 @@ module.exports = /*#__PURE__*/JSON.parse('{"*":["about","acceptCharset","accessK
 /******/ 	// startup
 /******/ 	// Load entry module and return exports
 /******/ 	// This entry module used 'module' so it can't be inlined
-/******/ 	let __webpack_exports__ = __webpack_require__(4246);
+/******/ 	let __webpack_exports__ = __webpack_require__(6831);
 /******/ 	module.exports = __webpack_exports__;
 /******/ 	
 /******/ })()