@readme/markdown 15.7.2 → 15.8.0

package/dist/processor/plugin/strip-tags.d.ts

@@ -0,0 +1,31 @@
+import type { Program } from 'estree';
+import type { Root } from 'hast';
+import type { Plugin, Transformer } from 'unified';
+/**
+ * Tags removed from user-provided content because rendering them executes in the
+ * page. Add an entry to cover another vector; nothing else needs to change.
+ *
+ * Deliberately narrow for now — `<script>` is the only vector this plugin claims
+ * to close. Broader parity with the `md` sanitization schema (`javascript:` URLs,
+ * `on*` handlers, `<iframe>`, `<object>`, …) is tracked in readmeio/markdown#1526.
+ */
+export declare const STRIPPED_TAG_NAMES: Set<string>;
+/**
+ * Removes matching elements and their subtrees when `sanitize` is enabled.
+ *
+ * Explicit `HTMLBlock`s are an intentional exception, matching legacy: their
+ * scripts live in a string prop rather than as elements, so they never appear
+ * in SSR HTML, and they only execute client-side when the author opts in via
+ * `runScripts`.
+ */
+export declare const rehypeStripTags: () => Transformer<Root, Root>;
+/**
+ * JSX inside expressions and exports stays in ESTree, outside the HAST pass.
+ * Strip it before evaluation in mdxish or after JSX compilation in MDX.
+ *
+ * Elements are spliced out of JSX children and replaced with `null` anywhere
+ * else, which React renders as nothing.
+ */
+export declare const stripJsxTags: (program: Program) => Program;
+/** `stripJsxTags` as a recma plugin, for the `mdx` compile pipeline. */
+export declare const recmaStripTags: Plugin<[], Program>;

package/dist/processor/transform/mdxish/evaluate-exports.d.ts

@@ -11,6 +11,10 @@ declare module 'hast' {
         mdxishScope?: MdxishScope;
     }
 }
+interface Options {
+    /** Drop `STRIPPED_TAG_NAMES` JSX from the exported code before it is evaluated. */
+    sanitize?: boolean;
+}
 /**
  * Evaluate `export const/function` declarations introduced by mdxjsEsm nodes.
  *
@@ -23,5 +27,5 @@ declare module 'hast' {
  * Any evaluation error is consumed and logged. We don't throw because it's
  * against the spirit of this engine to be less permissive than MDX needs.
  */
-declare const evaluateExports: Plugin<[], Root>;
+declare const evaluateExports: Plugin<[Options?], Root>;
 export default evaluateExports;

package/dist/render-fixture.node.js

@@ -19045,7 +19045,7 @@ module.exports = function () {
 
 /***/ },
 
-/***/ 5072
+/***/ 6829
 (module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
@@ -114138,6 +114138,133 @@ const hardBreaks = () => tree => {
 };
 /* harmony default export */ const hard_breaks = (hardBreaks);
 
+;// ./processor/plugin/strip-tags.ts
+
+/**
+ * Tags removed from user-provided content because rendering them executes in the
+ * page. Add an entry to cover another vector; nothing else needs to change.
+ *
+ * Deliberately narrow for now — `<script>` is the only vector this plugin claims
+ * to close. Broader parity with the `md` sanitization schema (`javascript:` URLs,
+ * `on*` handlers, `<iframe>`, `<object>`, …) is tracked in readmeio/markdown#1526.
+ */
+const STRIPPED_TAG_NAMES = new Set(['script']);
+/** JSX names starting with a capital are component references, not literal tags. */
+const LITERAL_TAG_NAME = /^[a-z]/;
+/**
+ * Whether a node would render as one of the stripped literal DOM elements.
+ * Browsers match tag names case-insensitively, so `<sCrIpT>` executes too.
+ *
+ * `<Script />` and friends are component references and are left alone.
+ */
+const isStrippedTag = (node) => {
+    if (node.type === 'element')
+        return STRIPPED_TAG_NAMES.has(node.tagName.toLowerCase());
+    if (node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') {
+        const name = node.name ?? '';
+        return LITERAL_TAG_NAME.test(name) && STRIPPED_TAG_NAMES.has(name.toLowerCase());
+    }
+    return false;
+};
+/**
+ * Removes matching elements and their subtrees when `sanitize` is enabled.
+ *
+ * Explicit `HTMLBlock`s are an intentional exception, matching legacy: their
+ * scripts live in a string prop rather than as elements, so they never appear
+ * in SSR HTML, and they only execute client-side when the author opts in via
+ * `runScripts`.
+ */
+const rehypeStripTags = () => {
+    return (tree) => {
+        visit(tree, isStrippedTag, (_node, index, parent) => {
+            parent.children.splice(index, 1);
+            return [(/* inlined export .SKIP */"skip"), index];
+        });
+    };
+};
+/** The automatic-runtime factories MDX compiles JSX into. */
+const JSX_FACTORIES = new Set(['_jsx', '_jsxs', '_jsxDEV']);
+/**
+ * Matches raw JSX and compiled `_jsx('tag', …)` calls. MDX may rewrite literal
+ * tags as `_components.<tag>` so a `components` prop can override them.
+ */
+const isStrippedJsxElement = (node) => {
+    if (node.type === 'JSXElement') {
+        const { name } = node.openingElement;
+        if (name.type === 'JSXIdentifier') {
+            return LITERAL_TAG_NAME.test(name.name) && STRIPPED_TAG_NAMES.has(name.name.toLowerCase());
+        }
+        return (name.type === 'JSXMemberExpression' &&
+            name.object.type === 'JSXIdentifier' &&
+            name.object.name === '_components' &&
+            STRIPPED_TAG_NAMES.has(name.property.name.toLowerCase()));
+    }
+    if (node.type === 'CallExpression' && node.callee.type === 'Identifier' && JSX_FACTORIES.has(node.callee.name)) {
+        const [tag] = node.arguments;
+        if (!tag)
+            return false;
+        if (tag.type === 'Literal')
+            return typeof tag.value === 'string' && STRIPPED_TAG_NAMES.has(tag.value.toLowerCase());
+        return (tag.type === 'MemberExpression' &&
+            tag.object.type === 'Identifier' &&
+            tag.object.name === '_components' &&
+            tag.property.type === 'Identifier' &&
+            STRIPPED_TAG_NAMES.has(tag.property.name.toLowerCase()));
+    }
+    return false;
+};
+const isEstreeNode = (value) => typeof value === 'object' && value !== null && typeof value.type === 'string';
+const nullLiteral = () => ({ type: 'Literal', value: null });
+/**
+ * JSX inside expressions and exports stays in ESTree, outside the HAST pass.
+ * Strip it before evaluation in mdxish or after JSX compilation in MDX.
+ *
+ * Elements are spliced out of JSX children and replaced with `null` anywhere
+ * else, which React renders as nothing.
+ */
+const stripJsxTags = (program) => {
+    const walk = (node) => {
+        const record = node;
+        Object.keys(record).forEach(key => {
+            if (key === 'loc' || key === 'range' || key === 'position')
+                return;
+            const value = record[key];
+            if (Array.isArray(value)) {
+                for (let i = value.length - 1; i >= 0; i -= 1) {
+                    const child = value[i];
+                    if (isEstreeNode(child)) {
+                        if (isStrippedJsxElement(child)) {
+                            if (key === 'children')
+                                value.splice(i, 1);
+                            else
+                                value[i] = nullLiteral();
+                        }
+                        else {
+                            walk(child);
+                        }
+                    }
+                }
+                return;
+            }
+            if (!isEstreeNode(value))
+                return;
+            if (isStrippedJsxElement(value)) {
+                record[key] =
+                    node.type === 'JSXAttribute' ? { type: 'JSXExpressionContainer', expression: nullLiteral() } : nullLiteral();
+            }
+            else {
+                walk(value);
+            }
+        });
+    };
+    walk(program);
+    return program;
+};
+/** `stripJsxTags` as a recma plugin, for the `mdx` compile pipeline. */
+const recmaStripTags = () => tree => {
+    stripJsxTags(tree);
+};
+
 ;// ./node_modules/estree-util-value-to-estree/dist/estree-util-value-to-estree.js
 /**
  * Create an ESTree identifier node for a given name.
@@ -116875,6 +117002,7 @@ const tocHastToMdx = (toc, components, variables) => {
 
 
 
+
 const sanitizeSchema = cjs_default()(defaultSchema, {
     attributes: {
         a: ['target'],
@@ -116883,7 +117011,10 @@ const sanitizeSchema = cjs_default()(defaultSchema, {
         href: ['doc', 'ref', 'blog', 'changelog', 'page'],
     },
 });
-const compile_compile = (text, { components = {}, missingComponents, copyButtons, useTailwind, hardBreaks, ...opts } = {}) => {
+const compile_compile = (text, { components = {}, missingComponents, copyButtons, useTailwind, hardBreaks, sanitize = false, 
+// Pulled out of `...opts` so a caller's plugins extend the pipeline instead of
+// replacing it — otherwise the spread below would drop `rehypeStripTags`.
+remarkPlugins: userRemarkPlugins, rehypePlugins: userRehypePlugins, recmaPlugins: userRecmaPlugins, ...opts } = {}) => {
     // Destructure at runtime to avoid circular dependency issues
     const { codeTabsTransformer, ...transforms } = defaultTransforms;
     const remarkPlugins = [
@@ -116901,7 +117032,12 @@ const compile_compile = (text, { components = {}, missingComponents, copyButtons
     if (useTailwind) {
         remarkPlugins.push([transform_tailwind, { components }]);
     }
-    const rehypePlugins = [...ast_processor_rehypePlugins, [rehypeToc, { components }]];
+    remarkPlugins.push(...(userRemarkPlugins ?? []));
+    const rehypePlugins = [
+        ...ast_processor_rehypePlugins,
+        [rehypeToc, { components }],
+        ...(userRehypePlugins ?? []),
+    ];
     if (opts.format === 'md') {
         /**
          * When running in `md` format we need to sanitize the content for security reasons.
@@ -116919,12 +117055,23 @@ const compile_compile = (text, { components = {}, missingComponents, copyButtons
         ]);
         rehypePlugins.push([rehypeSanitize, sanitizeSchema]);
     }
+    const recmaPlugins = [...(userRecmaPlugins ?? [])];
+    // In `mdx` format a literal <script> parses as JSX rather than raw HTML, so it
+    // bypasses sanitization entirely — strip it in every format. Must stay last:
+    // in `md` format raw HTML isn't an element until `rehypeRaw` has run. A tag
+    // inside an expression or export is code, not an element, so the recma pass
+    // catches it in the compiled program instead.
+    if (sanitize) {
+        rehypePlugins.push(rehypeStripTags);
+        recmaPlugins.push(recmaStripTags);
+    }
     try {
         const vfile = compileSync(text, {
             outputFormat: 'function-body',
             providerImportSource: '#',
             remarkPlugins,
             rehypePlugins,
+            recmaPlugins,
             ...opts,
         });
         const string = String(vfile)
@@ -123598,6 +123745,7 @@ const collectImportValues = (importDeclarations, registry = defaultModuleRegistr
 
 
 
+
 /**
  * Recursively extract all identifier names introduced by a binding pattern.
  * Handles destructuring (`{ a, b }`, `[x, y]`), rest elements (`...rest`),
@@ -123642,7 +123790,7 @@ const collectExportNames = (declaration) => {
  * Any evaluation error is consumed and logged. We don't throw because it's
  * against the spirit of this engine to be less permissive than MDX needs.
  */
-const evaluateExports = () => (tree, file) => {
+const evaluateExports = (opts) => (tree, file) => {
     const programBody = [];
     const exportNames = [];
     const importDeclarations = [];
@@ -123688,6 +123836,8 @@ const evaluateExports = () => (tree, file) => {
     // Evaluate the declarations together at once in a single sandboxed Function
     try {
         const program = { type: 'Program', sourceType: 'module', body: programBody };
+        if (opts?.sanitize)
+            stripJsxTags(program);
         buildJsx(program, { runtime: 'classic', pragma: 'React.createElement', pragmaFrag: 'React.Fragment' });
         const { value: source } = toJs(program);
         // Make sure import values are available in the scope
@@ -127884,6 +128034,7 @@ function loadComponents() {
 
 
 
+
 
 
 const defaultTransformers = [
@@ -128010,7 +128161,7 @@ function mdxishMdastToMd(mdast) {
  * @see .claude/context/MDXish/Processor Overview.md
  */
 function mdxish(mdContent, opts = {}) {
-    const { components: userComponents = {}, hardBreaks: enableHardBreaks = true, safeMode = false, variables } = opts;
+    const { components: userComponents = {}, hardBreaks: enableHardBreaks = true, safeMode = false, sanitize = false, variables, } = opts;
     const components = {
         ...loadComponents(),
         ...userComponents,
@@ -128021,7 +128172,7 @@ function mdxish(mdContent, opts = {}) {
     const contentWithoutComments = restoreCodeBlocks(withoutComments, protectedCode);
     const { processor, parserReadyContent } = mdxishAstProcessor(contentWithoutComments, opts);
     processor
-        .use(safeMode ? undefined : evaluate_exports) // Evaluate `export const/function` and stash scope on file.data.mdxishScope
+        .use(safeMode ? undefined : evaluate_exports, { sanitize }) // Evaluate `export const/function` and stash scope on file.data.mdxishScope
         .use(enableHardBreaks ? hard_breaks : undefined) // Must precede evaluateExpressions to avoid splitting the \n in an evaluated template literal into a <br> node
         .use(safeMode ? undefined : evaluate_expressions, { components, variables }) // Evaluate self-contained MDX expressions (e.g. `{1+1}`)
         .use(safeMode ? undefined : evaluate_style_block_expressions) // Evaluate `<style>{`...`}</style>` template literals into plain CSS
@@ -128032,6 +128183,7 @@ function mdxish(mdContent, opts = {}) {
         .use(restoreBooleanProperties)
         .use(safeMode ? undefined : resolve_deferred_attribute_expression_props) // Evaluate deferred attribute expressions on mdx-jsx nodes (now past rehypeRaw's clone)
         .use(normalize_mdx_jsx_nodes) // Rewrite `mdx-jsx` back to standard `element` nodes for downstream plugins
+        .use(sanitize ? rehypeStripTags : undefined) // Strip STRIPPED_TAG_NAMES elements; this pipeline has no sanitization step
         .use(rehypeFlattenTableCellParagraphs) // Remove <p> wrappers inside table cells to prevent margin issues
         .use(mdxish_mermaid) // Add mermaid-render className to pre wrappers
         .use(heading_slugs)
@@ -129114,7 +129266,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__(5072);
+/******/ 	let __webpack_exports__ = __webpack_require__(6829);
 /******/ 	module.exports = __webpack_exports__;
 /******/ 	
 /******/ })()