@readme/markdown 14.13.2 → 14.14.0

package/dist/index.d.ts

@@ -6,7 +6,7 @@ declare const utils: {
     getHref: typeof getHref;
     calloutIcons: {};
 };
-export { compile, exports, FLOW_TYPES, hast, INLINE_ONLY_PARENT_TYPES, run, mdast, mdastV6, mdx, mdxish, mdxishAstProcessor, mdxishMdastToMd, mdxishTags, extractToc, migrate, mix, plain, renderMdxish, remarkPlugins, stripComments, tags, } from './lib';
+export { compile, exports, FLOW_TYPES, hast, htmlToMarkdown, INLINE_ONLY_PARENT_TYPES, run, mdast, mdastV6, mdx, mdxish, mdxishAstProcessor, mdxishMdastToMd, mdxishTags, extractToc, migrate, mix, plain, renderMdxish, remarkPlugins, stripComments, tags, } from './lib';
 export type { MdxishOpts, RenderMdxishOpts, RunOpts } from './lib';
 export { default as Owlmoji } from './lib/owlmoji';
 export { Components, utils };

package/dist/lib/htmlToMarkdown.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns the Markdown form of `html`, or an empty string when there is no
+ * usable input. Synchronous, so it can run inside non-async serializers.
+ */
+export default function htmlToMarkdown(html?: string | null): string;

package/dist/lib/index.d.ts

@@ -4,6 +4,7 @@ export { default as astProcessor, remarkPlugins } from './ast-processor';
 export { default as compile } from './compile';
 export { default as exports } from './exports';
 export { default as hast } from './hast';
+export { default as htmlToMarkdown } from './htmlToMarkdown';
 export { default as mdast } from './mdast';
 export { default as mdastV6 } from './mdastV6';
 export { default as mdx } from './mdx';

package/dist/main.js

@@ -11602,6 +11602,7 @@ __webpack_require__.d(__webpack_exports__, {
   extractToc: () => (/* reexport */ lib_extractToc),
   gemojiRegex: () => (/* reexport */ gemoji_regex),
   hast: () => (/* reexport */ lib_hast),
+  htmlToMarkdown: () => (/* reexport */ htmlToMarkdown),
   mdast: () => (/* reexport */ lib_mdast),
   mdastV6: () => (/* reexport */ lib_mdastV6),
   mdx: () => (/* reexport */ lib_mdx),
@@ -54510,6 +54511,13 @@ const mdast = (text, opts = {}) => {
  * to parse expressions containing JSX.
  */
 const jsxAcornParser = external_acorn_.Parser.extend(acorn_jsx_default()());
+/**
+ * Disables CommonMark's indented-code-block construct (4+ spaces)
+ * The micromark tokenizers use follow the CommonMark specification: https://spec.commonmark.org/0.28/#indented-code-blocks
+ * So any lines indented 4+ spaces are considered as a code block,
+ * which is unexpected from users that used MDX before.
+ */
+const disableIndentedCode = { disable: { null: ['codeIndented'] } };
 /**
  * Evaluate a JavaScript expression source and return its value.
  *
@@ -92494,185 +92502,70 @@ const hast = (text, opts = {}) => {
 };
 /* harmony default export */ const lib_hast = (hast);
 
-;// ./processor/migration/emphasis.ts
-
-const emphasis_strongTest = (node) => ['emphasis', 'strong'].includes(node.type);
-const addSpaceBefore = (index, parent) => {
-    if (!(index > 0 && parent.children[index - 1]))
-        return;
-    const prev = parent.children[index - 1];
-    if (!('value' in prev) || prev.value.endsWith(' ') || prev.type === 'escape')
-        return;
-    parent.children.splice(index, 0, { type: 'text', value: ' ' });
-};
-const addSpaceAfter = (index, parent) => {
-    if (!(index < parent.children.length - 1 && parent.children[index + 1]))
-        return;
-    const nextChild = parent.children[index + 1];
-    if (!('value' in nextChild) || nextChild.value.startsWith(' '))
-        return;
-    parent.children.splice(index + 1, 0, { type: 'text', value: ' ' });
-};
-const trimEmphasis = (node, index, parent) => {
-    let trimmed = false;
-    visit(node, 'text', (child) => {
-        const newValue = child.value.trimStart();
-        if (newValue !== child.value) {
-            trimmed = true;
-            child.value = newValue;
-        }
-        return EXIT;
-    });
-    visit(node, 'text', (child) => {
-        const newValue = child.value.trimEnd();
-        if (newValue !== child.value) {
-            trimmed = true;
-            child.value = newValue;
-        }
-        return EXIT;
-    }, true);
-    if (trimmed) {
-        addSpaceBefore(index, parent);
-        addSpaceAfter(index, parent);
-    }
-};
-const emphasisTransfomer = () => (tree) => {
-    visit(tree, emphasis_strongTest, trimEmphasis);
-    return tree;
-};
-/* harmony default export */ const migration_emphasis = (emphasisTransfomer);
+;// ./node_modules/rehype-parse/lib/index.js
+/**
+ * @import {Root} from 'hast'
+ * @import {Options as FromHtmlOptions} from 'hast-util-from-html'
+ * @import {Parser, Processor} from 'unified'
+ */
 
-;// ./processor/migration/images.ts
+/**
+ * @typedef {Omit<FromHtmlOptions, 'onerror'> & RehypeParseFields} Options
+ *   Configuration.
+ *
+ * @typedef RehypeParseFields
+ *   Extra fields.
+ * @property {boolean | null | undefined} [emitParseErrors=false]
+ *   Whether to emit parse errors while parsing (default: `false`).
+ *
+ *   > 👉 **Note**: parse errors are currently being added to HTML.
+ *   > Not all errors emitted by parse5 (or us) are specced yet.
+ *   > Some documentation may still be missing.
+ */
 
-const images_imageTransformer = () => tree => {
-    visit(tree, 'image', (image) => {
-        if (image.data?.hProperties?.className === 'border') {
-            image.data.hProperties.border = true;
-        }
-    });
-};
-/* harmony default export */ const migration_images = (images_imageTransformer);
 
-;// ./processor/migration/linkReference.ts
 
-const linkReferenceTransformer = () => (tree) => {
-    visit(tree, 'linkReference', (node, index, parent) => {
-        const definitions = {};
-        visit(tree, 'definition', (def) => {
-            definitions[def.identifier] = def;
-        });
-        if (node.label === node.identifier && parent) {
-            if (!(node.identifier in definitions)) {
-                parent.children[index] = {
-                    type: 'text',
-                    value: `[${node.label}]`,
-                    position: node.position,
-                };
-            }
-        }
-    });
-    return tree;
-};
-/* harmony default export */ const migration_linkReference = (linkReferenceTransformer);
+/**
+ * Plugin to add support for parsing from HTML.
+ *
+ * > 👉 **Note**: this is not an XML parser.
+ * > It supports SVG as embedded in HTML.
+ * > It does not support the features available in XML.
+ * > Passing SVG files might break but fragments of modern SVG should be fine.
+ * > Use [`xast-util-from-xml`][xast-util-from-xml] to parse XML.
+ *
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {undefined}
+ *   Nothing.
+ */
+function rehypeParse(options) {
+  /** @type {Processor<Root>} */
+  // @ts-expect-error: TS in JSDoc generates wrong types if `this` is typed regularly.
+  const self = this
+  const {emitParseErrors, ...settings} = {...self.data('settings'), ...options}
 
-;// ./processor/migration/table-cell.ts
+  self.parser = parser
 
-const magicIndex = (i, j) => `${i === 0 ? 'h' : `${i - 1}`}-${j}`;
-const isInlineHtml = node => node.type === 'html' && !node.block;
-// @note: This regex is detect malformed lists that were created by the
-// markdown editor. Consider the following markdown:
-//
-// ```
-// * item 1
-// * item 2
-// * item 3
-// ```
-//
-// This is a perfectly valid list. But when you put that text into a table
-// cell, the editor does **bad** things. After a save and load cycle, it gets
-// converted to this:
-//
-// ```
-// \_ item 1
-// \_ item 2
-// \* item 3
-// ```
-//
-// The following regex attempts to detect this pattern, and we'll convert it to
-// something more standard.
-const psuedoListRegex = /^(?![ \t]*([*_]+).*\1[ \t]*$)(?<ws>[ \t]*)\\?([*_])\s*(?<item>.*)$/gm;
-const migrateTableCells = (vfile, rdmd) => (table) => {
-    let json;
-    try {
-        const { position } = table;
-        if (position) {
-            json = JSON.parse(vfile
-                .toString()
-                .slice(position.start.offset, position.end.offset)
-                .replace(/.*\[block:parameters\](.*)\[\/block\].*/s, '$1'));
-        }
-    }
-    catch (err) {
-        /**
-         * This failure case is already handled by the following logic. Plus,
-         * because it's being handled internally, there's no way for our
-         * migration script to catch the error or keep track of it, and it just
-         * ends up blowing up the output logs.
-         */
-        // console.error(err);
-    }
-    visit(table, 'tableRow', (row, i) => {
-        visit(row, 'tableCell', (cell, j) => {
-            let children = cell.children;
-            if (json && json.data[magicIndex(i, j)]) {
-                const string = json.data[magicIndex(i, j)].replace(psuedoListRegex, '$<ws>- $<item>');
-                children = rdmd.mdast(string).children;
+  /**
+   * @type {Parser<Root>}
+   */
+  function parser(document, file) {
+    return fromHtml(document, {
+      ...settings,
+      onerror: emitParseErrors
+        ? function (message) {
+            if (file.path) {
+              message.name = file.path + ':' + message.name
+              message.file = file.path
             }
-            cell.children =
-                children.length > 1 && !children.some(isInlineHtml)
-                    ? children
-                    : [{ type: 'paragraph', children }];
-            return SKIP;
-        });
-        return SKIP;
-    });
-    visit(table, 'inlineCode', (code) => {
-        if (code.value.includes('\n')) {
-            code.type = 'code';
-        }
-    });
-};
-function tableCellTransformer() {
-    const rdmd = this.data('rdmd');
-    return (tree, vfile) => {
-        visit(tree, 'table', migrateTableCells(vfile, rdmd));
-        return tree;
-    };
-}
-/* harmony default export */ const table_cell = (tableCellTransformer);
 
-;// ./processor/migration/index.ts
-
-
-
-
-const transformers = [migration_emphasis, migration_images, migration_linkReference, table_cell];
-/* harmony default export */ const migration = (transformers);
-
-;// ./lib/mdastV6.ts
-
-const migrationNormalize = (doc) => {
-    return doc.replaceAll(/^(<!--.*?)\\-->$/gms, '$1-->');
-};
-const mdastV6 = (doc, { rdmd }) => {
-    const [_normalizedDoc] = rdmd.setup(doc);
-    const normalizedDoc = migrationNormalize(_normalizedDoc);
-    const proc = rdmd.processor().use(migration).data('rdmd', rdmd);
-    const tree = proc.parse(normalizedDoc);
-    proc.runSync(tree, normalizedDoc);
-    return tree;
-};
-/* harmony default export */ const lib_mdastV6 = (mdastV6);
+            file.messages.push(message)
+          }
+        : undefined
+    })
+  }
+}
 
 ;// ./node_modules/hast-util-is-element/lib/index.js
 /**
@@ -97199,6 +97092,227 @@ function rehypeRemark(destination, options) {
   }
 }
 
+;// ./lib/htmlToMarkdown.ts
+
+
+
+
+
+/**
+ * Converts an HTML fragment to GitHub-flavored Markdown.
+ *
+ * `remark-gfm` is load-bearing: without it, `<table>` and `<del>` input throws
+ * at serialization. `iframe` (default: becomes a link) and `noscript` (default:
+ * keeps its text) are dropped by the handlers so raw markup never leaks;
+ * `script`, `style`, and `template` already drop by default and are overridden
+ * defensively. HTML comments are dropped via `nodeHandlers`.
+ */
+const processor = unified()
+    .use(rehypeParse, { fragment: true })
+    .use(rehypeRemark, {
+    // A comment is a `comment` node, not an element, so it goes in
+    // `nodeHandlers` rather than `handlers`.
+    handlers: {
+        iframe: () => undefined,
+        noscript: () => undefined,
+        script: () => undefined,
+        style: () => undefined,
+        template: () => undefined,
+    },
+    nodeHandlers: { comment: () => undefined },
+})
+    .use(remarkGfm)
+    .use(remarkStringify, { bullet: '-', emphasis: '_', fences: true });
+/**
+ * Returns the Markdown form of `html`, or an empty string when there is no
+ * usable input. Synchronous, so it can run inside non-async serializers.
+ */
+function htmlToMarkdown(html) {
+    if (typeof html !== 'string' || !html.trim())
+        return '';
+    return processor.processSync(html).toString().trim();
+}
+
+;// ./processor/migration/emphasis.ts
+
+const emphasis_strongTest = (node) => ['emphasis', 'strong'].includes(node.type);
+const addSpaceBefore = (index, parent) => {
+    if (!(index > 0 && parent.children[index - 1]))
+        return;
+    const prev = parent.children[index - 1];
+    if (!('value' in prev) || prev.value.endsWith(' ') || prev.type === 'escape')
+        return;
+    parent.children.splice(index, 0, { type: 'text', value: ' ' });
+};
+const addSpaceAfter = (index, parent) => {
+    if (!(index < parent.children.length - 1 && parent.children[index + 1]))
+        return;
+    const nextChild = parent.children[index + 1];
+    if (!('value' in nextChild) || nextChild.value.startsWith(' '))
+        return;
+    parent.children.splice(index + 1, 0, { type: 'text', value: ' ' });
+};
+const trimEmphasis = (node, index, parent) => {
+    let trimmed = false;
+    visit(node, 'text', (child) => {
+        const newValue = child.value.trimStart();
+        if (newValue !== child.value) {
+            trimmed = true;
+            child.value = newValue;
+        }
+        return EXIT;
+    });
+    visit(node, 'text', (child) => {
+        const newValue = child.value.trimEnd();
+        if (newValue !== child.value) {
+            trimmed = true;
+            child.value = newValue;
+        }
+        return EXIT;
+    }, true);
+    if (trimmed) {
+        addSpaceBefore(index, parent);
+        addSpaceAfter(index, parent);
+    }
+};
+const emphasisTransfomer = () => (tree) => {
+    visit(tree, emphasis_strongTest, trimEmphasis);
+    return tree;
+};
+/* harmony default export */ const migration_emphasis = (emphasisTransfomer);
+
+;// ./processor/migration/images.ts
+
+const images_imageTransformer = () => tree => {
+    visit(tree, 'image', (image) => {
+        if (image.data?.hProperties?.className === 'border') {
+            image.data.hProperties.border = true;
+        }
+    });
+};
+/* harmony default export */ const migration_images = (images_imageTransformer);
+
+;// ./processor/migration/linkReference.ts
+
+const linkReferenceTransformer = () => (tree) => {
+    visit(tree, 'linkReference', (node, index, parent) => {
+        const definitions = {};
+        visit(tree, 'definition', (def) => {
+            definitions[def.identifier] = def;
+        });
+        if (node.label === node.identifier && parent) {
+            if (!(node.identifier in definitions)) {
+                parent.children[index] = {
+                    type: 'text',
+                    value: `[${node.label}]`,
+                    position: node.position,
+                };
+            }
+        }
+    });
+    return tree;
+};
+/* harmony default export */ const migration_linkReference = (linkReferenceTransformer);
+
+;// ./processor/migration/table-cell.ts
+
+const magicIndex = (i, j) => `${i === 0 ? 'h' : `${i - 1}`}-${j}`;
+const isInlineHtml = node => node.type === 'html' && !node.block;
+// @note: This regex is detect malformed lists that were created by the
+// markdown editor. Consider the following markdown:
+//
+// ```
+// * item 1
+// * item 2
+// * item 3
+// ```
+//
+// This is a perfectly valid list. But when you put that text into a table
+// cell, the editor does **bad** things. After a save and load cycle, it gets
+// converted to this:
+//
+// ```
+// \_ item 1
+// \_ item 2
+// \* item 3
+// ```
+//
+// The following regex attempts to detect this pattern, and we'll convert it to
+// something more standard.
+const psuedoListRegex = /^(?![ \t]*([*_]+).*\1[ \t]*$)(?<ws>[ \t]*)\\?([*_])\s*(?<item>.*)$/gm;
+const migrateTableCells = (vfile, rdmd) => (table) => {
+    let json;
+    try {
+        const { position } = table;
+        if (position) {
+            json = JSON.parse(vfile
+                .toString()
+                .slice(position.start.offset, position.end.offset)
+                .replace(/.*\[block:parameters\](.*)\[\/block\].*/s, '$1'));
+        }
+    }
+    catch (err) {
+        /**
+         * This failure case is already handled by the following logic. Plus,
+         * because it's being handled internally, there's no way for our
+         * migration script to catch the error or keep track of it, and it just
+         * ends up blowing up the output logs.
+         */
+        // console.error(err);
+    }
+    visit(table, 'tableRow', (row, i) => {
+        visit(row, 'tableCell', (cell, j) => {
+            let children = cell.children;
+            if (json && json.data[magicIndex(i, j)]) {
+                const string = json.data[magicIndex(i, j)].replace(psuedoListRegex, '$<ws>- $<item>');
+                children = rdmd.mdast(string).children;
+            }
+            cell.children =
+                children.length > 1 && !children.some(isInlineHtml)
+                    ? children
+                    : [{ type: 'paragraph', children }];
+            return SKIP;
+        });
+        return SKIP;
+    });
+    visit(table, 'inlineCode', (code) => {
+        if (code.value.includes('\n')) {
+            code.type = 'code';
+        }
+    });
+};
+function tableCellTransformer() {
+    const rdmd = this.data('rdmd');
+    return (tree, vfile) => {
+        visit(tree, 'table', migrateTableCells(vfile, rdmd));
+        return tree;
+    };
+}
+/* harmony default export */ const table_cell = (tableCellTransformer);
+
+;// ./processor/migration/index.ts
+
+
+
+
+const transformers = [migration_emphasis, migration_images, migration_linkReference, table_cell];
+/* harmony default export */ const migration = (transformers);
+
+;// ./lib/mdastV6.ts
+
+const migrationNormalize = (doc) => {
+    return doc.replaceAll(/^(<!--.*?)\\-->$/gms, '$1-->');
+};
+const mdastV6 = (doc, { rdmd }) => {
+    const [_normalizedDoc] = rdmd.setup(doc);
+    const normalizedDoc = migrationNormalize(_normalizedDoc);
+    const proc = rdmd.processor().use(migration).data('rdmd', rdmd);
+    const tree = proc.parse(normalizedDoc);
+    proc.runSync(tree, normalizedDoc);
+    return tree;
+};
+/* harmony default export */ const lib_mdastV6 = (mdastV6);
+
 ;// ./processor/compile/anchor.ts
 
 
@@ -102517,6 +102631,7 @@ function mdxComponent() {
 
 
 
+
 
 
 const buildInlineMdProcessor = (safeMode) => {
@@ -102524,7 +102639,7 @@ const buildInlineMdProcessor = (safeMode) => {
     // body (e.g. a `<Callout>`) is captured as one html node. Without it, blank
     // lines between rows let CommonMark HTML block type 6 fragment the table and
     // its rows spill out as text / indented code blocks (CX-3705).
-    const micromarkExts = [jsxTable(), mdxComponent(), syntax_gemoji(), legacyVariable(), magicBlock()];
+    const micromarkExts = [disableIndentedCode, jsxTable(), mdxComponent(), syntax_gemoji(), legacyVariable(), magicBlock()];
     const fromMarkdownExts = [
         jsxTableFromMarkdown(),
         mdxComponentFromMarkdown(),
@@ -103835,71 +103950,6 @@ const generateSlugForHeadings = () => (tree) => {
 // EXTERNAL MODULE: external "@readme/variable"
 var variable_ = __webpack_require__(8167);
 var variable_default = /*#__PURE__*/__webpack_require__.n(variable_);
-;// ./node_modules/rehype-parse/lib/index.js
-/**
- * @import {Root} from 'hast'
- * @import {Options as FromHtmlOptions} from 'hast-util-from-html'
- * @import {Parser, Processor} from 'unified'
- */
-
-/**
- * @typedef {Omit<FromHtmlOptions, 'onerror'> & RehypeParseFields} Options
- *   Configuration.
- *
- * @typedef RehypeParseFields
- *   Extra fields.
- * @property {boolean | null | undefined} [emitParseErrors=false]
- *   Whether to emit parse errors while parsing (default: `false`).
- *
- *   > 👉 **Note**: parse errors are currently being added to HTML.
- *   > Not all errors emitted by parse5 (or us) are specced yet.
- *   > Some documentation may still be missing.
- */
-
-
-
-/**
- * Plugin to add support for parsing from HTML.
- *
- * > 👉 **Note**: this is not an XML parser.
- * > It supports SVG as embedded in HTML.
- * > It does not support the features available in XML.
- * > Passing SVG files might break but fragments of modern SVG should be fine.
- * > Use [`xast-util-from-xml`][xast-util-from-xml] to parse XML.
- *
- * @param {Options | null | undefined} [options]
- *   Configuration (optional).
- * @returns {undefined}
- *   Nothing.
- */
-function rehypeParse(options) {
-  /** @type {Processor<Root>} */
-  // @ts-expect-error: TS in JSDoc generates wrong types if `this` is typed regularly.
-  const self = this
-  const {emitParseErrors, ...settings} = {...self.data('settings'), ...options}
-
-  self.parser = parser
-
-  /**
-   * @type {Parser<Root>}
-   */
-  function parser(document, file) {
-    return fromHtml(document, {
-      ...settings,
-      onerror: emitParseErrors
-        ? function (message) {
-            if (file.path) {
-              message.name = file.path + ':' + message.name
-              message.file = file.path
-            }
-
-            file.messages.push(message)
-          }
-        : undefined
-    })
-  }
-}
-
 ;// ./lib/micromark/loose-html-entities/syntax.ts
 
 
@@ -106825,6 +106875,7 @@ function mdxishAstProcessor(mdContent, opts = {}) {
     // Parser extension for MDX expressions {}
     const mdxExprTextOnly = mdxExpressionLenient();
     const micromarkExts = [
+        disableIndentedCode,
         jsxTable(),
         magicBlock(),
         mdxComponent(),
@@ -107609,6 +107660,7 @@ async function stripComments(doc, { mdx, mdxish } = {}) {
 
 
 
+
 ;// ./index.tsx