decap-cms-widget-markdown 2.16.0-beta.0

package/dist/esm/MarkdownPreview.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _decapCmsUiDefault = require("decap-cms-ui-default");
+var _dompurify = _interopRequireDefault(require("dompurify"));
+var _serializers = require("./serializers");
+var _core = require("@emotion/core");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+class MarkdownPreview extends _react.default.Component {
+  render() {
+    const {
+      value,
+      getAsset,
+      resolveWidget,
+      field,
+      getRemarkPlugins
+    } = this.props;
+    if (value === null) {
+      return null;
+    }
+    const html = (0, _serializers.markdownToHtml)(value, {
+      getAsset,
+      resolveWidget
+    }, getRemarkPlugins === null || getRemarkPlugins === void 0 ? void 0 : getRemarkPlugins());
+    const toRender = field !== null && field !== void 0 && field.get('sanitize_preview', false) ? _dompurify.default.sanitize(html) : html;
+    return (0, _core.jsx)(_decapCmsUiDefault.WidgetPreviewContainer, {
+      dangerouslySetInnerHTML: {
+        __html: toRender
+      }
+    });
+  }
+}
+_defineProperty(MarkdownPreview, "propTypes", {
+  getAsset: _propTypes.default.func.isRequired,
+  resolveWidget: _propTypes.default.func.isRequired,
+  value: _propTypes.default.string
+});
+var _default = MarkdownPreview;
+exports.default = _default;

package/dist/esm/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.DecapCmsWidgetMarkdown = void 0;
+var _MarkdownControl = _interopRequireDefault(require("./MarkdownControl"));
+var _MarkdownPreview = _interopRequireDefault(require("./MarkdownPreview"));
+var _schema = _interopRequireDefault(require("./schema"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function Widget(opts = {}) {
+  return _objectSpread({
+    name: 'markdown',
+    controlComponent: _MarkdownControl.default,
+    previewComponent: _MarkdownPreview.default,
+    schema: _schema.default
+  }, opts);
+}
+const DecapCmsWidgetMarkdown = {
+  Widget,
+  controlComponent: _MarkdownControl.default,
+  previewComponent: _MarkdownPreview.default
+};
+exports.DecapCmsWidgetMarkdown = DecapCmsWidgetMarkdown;
+var _default = DecapCmsWidgetMarkdown;
+exports.default = _default;

package/dist/esm/regexHelper.js

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.combinePatterns = combinePatterns;
+exports.joinPatternSegments = joinPatternSegments;
+exports.replaceWhen = replaceWhen;
+var _last2 = _interopRequireDefault(require("lodash/last"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Joins an array of regular expressions into a single expression, without
+ * altering the received expressions.
+ */
+function joinPatternSegments(patterns) {
+  return patterns.map(p => p.source).join('');
+}
+
+/**
+ * Combines an array of regular expressions into a single expression, wrapping
+ * each in a non-capturing group and interposing alternation characters (|) so
+ * that each expression is executed separately.
+ */
+function combinePatterns(patterns) {
+  return patterns.map(p => `(?:${p.source})`).join('|');
+}
+
+/**
+ * Modify substrings within a string if they match a (global) pattern. Can be
+ * inverted to only modify non-matches.
+ *
+ * params:
+ * matchPattern - regexp - a regular expression to check for matches
+ * replaceFn - function - a replacement function that receives a matched
+ *   substring and returns a replacement substring
+ * text - string - the string to process
+ * invertMatchPattern - boolean - if true, non-matching substrings are modified
+ *   instead of matching substrings
+ */
+function replaceWhen(matchPattern, replaceFn, text, invertMatchPattern) {
+  /**
+   * Splits the string into an array of objects with the following shape:
+   *
+   * {
+   *   index: number - the index of the substring within the string
+   *   text: string - the substring
+   *   match: boolean - true if the substring matched `matchPattern`
+   * }
+   *
+   * Loops through matches via recursion (`RegExp.exec` tracks the loop
+   * internally).
+   */
+  function split(exp, text, acc) {
+    /**
+     * Get the next match starting from the end of the last match or start of
+     * string.
+     */
+    const match = exp.exec(text);
+    const lastEntry = (0, _last2.default)(acc);
+
+    /**
+     * `match` will be null if there are no matches.
+     */
+    if (!match) return acc;
+
+    /**
+     * If the match is at the beginning of the input string, normalize to a data
+     * object with the `match` flag set to `true`, and add to the accumulator.
+     */
+    if (match.index === 0) {
+      addSubstring(acc, 0, match[0], true);
+    } else if (!lastEntry) {
+      /**
+       * If there are no entries in the accumulator, convert the substring before
+       * the match to a data object (without the `match` flag set to true) and
+       * push to the accumulator, followed by a data object for the matching
+       * substring.
+       */
+      addSubstring(acc, 0, match.input.slice(0, match.index));
+      addSubstring(acc, match.index, match[0], true);
+    } else if (match.index === lastEntry.index + lastEntry.text.length) {
+      /**
+       * If the last entry in the accumulator immediately preceded the current
+       * matched substring in the original string, just add the data object for
+       * the matching substring to the accumulator.
+       */
+      addSubstring(acc, match.index, match[0], true);
+    } else {
+      /**
+       * Convert the substring before the match to a data object (without the
+       * `match` flag set to true), followed by a data object for the matching
+       * substring.
+       */
+      const nextIndex = lastEntry.index + lastEntry.text.length;
+      const nextText = match.input.slice(nextIndex, match.index);
+      addSubstring(acc, nextIndex, nextText);
+      addSubstring(acc, match.index, match[0], true);
+    }
+
+    /**
+     * Continue executing the expression.
+     */
+    return split(exp, text, acc);
+  }
+
+  /**
+   * Factory for converting substrings to data objects and adding to an output
+   * array.
+   */
+  function addSubstring(arr, index, text, match = false) {
+    arr.push({
+      index,
+      text,
+      match
+    });
+  }
+
+  /**
+   * Split the input string to an array of data objects, each representing a
+   * matching or non-matching string.
+   */
+  const acc = split(matchPattern, text, []);
+
+  /**
+   * Process the trailing substring after the final match, if one exists.
+   */
+  const lastEntry = (0, _last2.default)(acc);
+  if (!lastEntry) return replaceFn(text);
+  const nextIndex = lastEntry.index + lastEntry.text.length;
+  if (text.length > nextIndex) {
+    acc.push({
+      index: nextIndex,
+      text: text.slice(nextIndex)
+    });
+  }
+
+  /**
+   * Map the data objects in the accumulator to their string values, modifying
+   * matched strings with the replacement function. Modifies non-matches if
+   * `invertMatchPattern` is truthy.
+   */
+  const replacedText = acc.map(entry => {
+    const isMatch = invertMatchPattern ? !entry.match : entry.match;
+    return isMatch ? replaceFn(entry.text) : entry.text;
+  });
+
+  /**
+   * Return the joined string.
+   */
+  return replacedText.join('');
+}

package/dist/esm/schema.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = {
+  properties: {
+    minimal: {
+      type: 'boolean'
+    },
+    buttons: {
+      type: 'array',
+      items: {
+        type: 'string',
+        enum: ['bold', 'italic', 'code', 'link', 'heading-one', 'heading-two', 'heading-three', 'heading-four', 'heading-five', 'heading-six', 'quote', 'bulleted-list', 'numbered-list']
+      }
+    },
+    editor_components: {
+      type: 'array',
+      items: {
+        type: 'string'
+      }
+    },
+    modes: {
+      type: 'array',
+      items: {
+        type: 'string',
+        enum: ['raw', 'rich_text']
+      },
+      minItems: 1
+    }
+  }
+};
+exports.default = _default;

package/dist/esm/serializers/index.js

@@ -0,0 +1,233 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.htmlToSlate = htmlToSlate;
+exports.markdownToHtml = markdownToHtml;
+exports.markdownToRemark = markdownToRemark;
+exports.markdownToSlate = markdownToSlate;
+exports.remarkToMarkdown = remarkToMarkdown;
+exports.slateToMarkdown = slateToMarkdown;
+var _trimEnd2 = _interopRequireDefault(require("lodash/trimEnd"));
+var _unified = _interopRequireDefault(require("unified"));
+var _unistBuilder = _interopRequireDefault(require("unist-builder"));
+var _remarkParse = _interopRequireDefault(require("remark-parse"));
+var _remarkStringify = _interopRequireDefault(require("remark-stringify"));
+var _remarkRehype = _interopRequireDefault(require("remark-rehype"));
+var _rehypeStringify = _interopRequireDefault(require("rehype-stringify"));
+var _rehypeParse = _interopRequireDefault(require("rehype-parse"));
+var _rehypeRemark = _interopRequireDefault(require("rehype-remark"));
+var _remarkRehypeShortcodes = _interopRequireDefault(require("./remarkRehypeShortcodes"));
+var _rehypePaperEmoji = _interopRequireDefault(require("./rehypePaperEmoji"));
+var _remarkAssertParents = _interopRequireDefault(require("./remarkAssertParents"));
+var _remarkPaddedLinks = _interopRequireDefault(require("./remarkPaddedLinks"));
+var _remarkWrapHtml = _interopRequireDefault(require("./remarkWrapHtml"));
+var _remarkSlate = _interopRequireDefault(require("./remarkSlate"));
+var _remarkSquashReferences = _interopRequireDefault(require("./remarkSquashReferences"));
+var _remarkShortcodes = require("./remarkShortcodes");
+var _remarkEscapeMarkdownEntities = _interopRequireDefault(require("./remarkEscapeMarkdownEntities"));
+var _remarkStripTrailingBreaks = _interopRequireDefault(require("./remarkStripTrailingBreaks"));
+var _remarkAllowHtmlEntities = _interopRequireDefault(require("./remarkAllowHtmlEntities"));
+var _slateRemark = _interopRequireDefault(require("./slateRemark"));
+var _MarkdownControl = require("../MarkdownControl");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * This module contains all serializers for the Markdown widget.
+ *
+ * The value of a Markdown widget is transformed to various formats during
+ * editing, and these formats are referenced throughout serializer source
+ * documentation. Below is brief glossary of the formats used.
+ *
+ * - Markdown {string}
+ *   The stringified Markdown value. The value of the field is persisted
+ *   (stored) in this format, and the stringified value is also used when the
+ *   editor is in "raw" Markdown mode.
+ *
+ * - MDAST {object}
+ *   Also loosely referred to as "Remark". MDAST stands for MarkDown AST
+ *   (Abstract Syntax Tree), and is an object representation of a Markdown
+ *   document. Underneath, it's a Unist tree with a Markdown-specific schema.
+ *   MDAST syntax is a part of the Unified ecosystem, and powers the Remark
+ *   processor, so Remark plugins may be used.
+ *
+ * - HAST {object}
+ *   Also loosely referred to as "Rehype". HAST, similar to MDAST, is an object
+ *   representation of an HTML document.  The field value takes this format
+ *   temporarily before the document is stringified to HTML.
+ *
+ * - HTML {string}
+ *   The field value is stringifed to HTML for preview purposes - the HTML value
+ *   is never parsed, it is output only.
+ *
+ * - Slate Raw AST {object}
+ *   Slate's Raw AST is a very simple and unopinionated object representation of
+ *   a document in a Slate editor. We define our own Markdown-specific schema
+ *   for serialization to/from Slate's Raw AST and MDAST.
+ */
+
+/**
+ * Deserialize a Markdown string to an MDAST.
+ */
+function markdownToRemark(markdown, remarkPlugins) {
+  const processor = (0, _unified.default)().use(_remarkParse.default, {
+    fences: true,
+    commonmark: true
+  }).use(markdownToRemarkRemoveTokenizers, {
+    inlineTokenizers: ['url']
+  }).use(_remarkShortcodes.remarkParseShortcodes, {
+    plugins: (0, _MarkdownControl.getEditorComponents)()
+  }).use(_remarkAllowHtmlEntities.default).use(_remarkSquashReferences.default).use(remarkPlugins);
+
+  /**
+   * Parse the Markdown string input to an MDAST.
+   */
+  const parsed = processor.parse(markdown);
+
+  /**
+   * Further transform the MDAST with plugins.
+   */
+  const result = processor.runSync(parsed);
+  return result;
+}
+
+/**
+ * Remove named tokenizers from the parser, effectively deactivating them.
+ */
+function markdownToRemarkRemoveTokenizers({
+  inlineTokenizers
+}) {
+  inlineTokenizers && inlineTokenizers.forEach(tokenizer => {
+    delete this.Parser.prototype.inlineTokenizers[tokenizer];
+  });
+}
+
+/**
+ * Serialize an MDAST to a Markdown string.
+ */
+function remarkToMarkdown(obj, remarkPlugins) {
+  /**
+   * Rewrite the remark-stringify text visitor to simply return the text value,
+   * without encoding or escaping any characters. This means we're completely
+   * trusting the markdown that we receive.
+   */
+  function remarkAllowAllText() {
+    const Compiler = this.Compiler;
+    const visitors = Compiler.prototype.visitors;
+    visitors.text = node => node.value;
+  }
+
+  /**
+   * Provide an empty MDAST if no value is provided.
+   */
+  const mdast = obj || (0, _unistBuilder.default)('root', [(0, _unistBuilder.default)('paragraph', [(0, _unistBuilder.default)('text', '')])]);
+  const remarkToMarkdownPluginOpts = {
+    commonmark: true,
+    fences: true,
+    listItemIndent: '1',
+    /**
+     * Use asterisk for everything, it's the most versatile. Eventually using
+     * other characters should be an option.
+     */
+    bullet: '*',
+    emphasis: '*',
+    strong: '*',
+    rule: '-'
+  };
+  const processor = (0, _unified.default)().use({
+    settings: remarkToMarkdownPluginOpts
+  }).use(_remarkEscapeMarkdownEntities.default).use(_remarkStripTrailingBreaks.default).use(_remarkStringify.default).use(remarkAllowAllText).use((0, _remarkShortcodes.createRemarkShortcodeStringifier)({
+    plugins: (0, _MarkdownControl.getEditorComponents)()
+  })).use(remarkPlugins);
+
+  /**
+   * Transform the MDAST with plugins.
+   */
+  const processedMdast = processor.runSync(mdast);
+
+  /**
+   * Serialize the MDAST to markdown.
+   */
+  const markdown = processor.stringify(processedMdast).replace(/\r?/g, '');
+
+  /**
+   * Return markdown with trailing whitespace removed.
+   */
+  return (0, _trimEnd2.default)(markdown);
+}
+
+/**
+ * Convert Markdown to HTML.
+ */
+function markdownToHtml(markdown, {
+  getAsset,
+  resolveWidget,
+  remarkPlugins = []
+} = {}) {
+  const mdast = markdownToRemark(markdown, remarkPlugins);
+  const hast = (0, _unified.default)().use(_remarkRehypeShortcodes.default, {
+    plugins: (0, _MarkdownControl.getEditorComponents)(),
+    getAsset,
+    resolveWidget
+  }).use(_remarkRehype.default, {
+    allowDangerousHTML: true
+  }).runSync(mdast);
+  const html = (0, _unified.default)().use(_rehypeStringify.default, {
+    allowDangerousHtml: true,
+    allowDangerousCharacters: true,
+    closeSelfClosing: true,
+    entities: {
+      useNamedReferences: true
+    }
+  }).stringify(hast);
+  return html;
+}
+
+/**
+ * Deserialize an HTML string to Slate's Raw AST. Currently used for HTML
+ * pastes.
+ */
+function htmlToSlate(html) {
+  const hast = (0, _unified.default)().use(_rehypeParse.default, {
+    fragment: true
+  }).parse(html);
+  const mdast = (0, _unified.default)().use(_rehypePaperEmoji.default).use(_rehypeRemark.default, {
+    minify: false
+  }).runSync(hast);
+  const slateRaw = (0, _unified.default)().use(_remarkAssertParents.default).use(_remarkPaddedLinks.default).use(_remarkWrapHtml.default).use(_remarkSlate.default).runSync(mdast);
+  return slateRaw;
+}
+
+/**
+ * Convert Markdown to Slate's Raw AST.
+ */
+function markdownToSlate(markdown, {
+  voidCodeBlock,
+  remarkPlugins = []
+} = {}) {
+  const mdast = markdownToRemark(markdown, remarkPlugins);
+  const slateRaw = (0, _unified.default)().use(_remarkWrapHtml.default).use(_remarkSlate.default, {
+    voidCodeBlock
+  }).runSync(mdast);
+  return slateRaw.children;
+}
+
+/**
+ * Convert a Slate Raw AST to Markdown.
+ *
+ * Requires shortcode plugins to parse shortcode nodes back to text.
+ *
+ * Note that Unified is not utilized for the conversion from Slate's Raw AST to
+ * MDAST. The conversion is manual because Unified can only operate on Unist
+ * trees.
+ */
+function slateToMarkdown(raw, {
+  voidCodeBlock,
+  remarkPlugins = []
+} = {}) {
+  const mdast = (0, _slateRemark.default)(raw, {
+    voidCodeBlock
+  });
+  const markdown = remarkToMarkdown(mdast, remarkPlugins);
+  return markdown;
+}

package/dist/esm/serializers/rehypePaperEmoji.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = rehypePaperEmoji;
+/**
+ * Dropbox Paper outputs emoji characters as images, and stores the actual
+ * emoji character in a `data-emoji-ch` attribute on the image. This plugin
+ * replaces the images with the emoji characters.
+ */
+function rehypePaperEmoji() {
+  function transform(node) {
+    if (node.tagName === 'img' && node.properties.dataEmojiCh) {
+      return {
+        type: 'text',
+        value: node.properties.dataEmojiCh
+      };
+    }
+    node.children = node.children ? node.children.map(transform) : node.children;
+    return node;
+  }
+  return transform;
+}

package/dist/esm/serializers/remarkAllowHtmlEntities.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = remarkAllowHtmlEntities;
+function remarkAllowHtmlEntities() {
+  this.Parser.prototype.inlineTokenizers.text = text;
+
+  /**
+   * This is a port of the `remark-parse` text tokenizer, adapted to exclude
+   * HTML entity decoding.
+   */
+  function text(eat, value, silent) {
+    var self = this;
+    var methods;
+    var tokenizers;
+    var index;
+    var length;
+    var subvalue;
+    var position;
+    var tokenizer;
+    var name;
+    var min;
+
+    /* istanbul ignore if - never used (yet) */
+    if (silent) {
+      return true;
+    }
+    methods = self.inlineMethods;
+    length = methods.length;
+    tokenizers = self.inlineTokenizers;
+    index = -1;
+    min = value.length;
+    while (++index < length) {
+      name = methods[index];
+      if (name === 'text' || !tokenizers[name]) {
+        continue;
+      }
+      tokenizer = tokenizers[name].locator;
+      if (!tokenizer) {
+        eat.file.fail('Missing locator: `' + name + '`');
+      }
+      position = tokenizer.call(self, value, 1);
+      if (position !== -1 && position < min) {
+        min = position;
+      }
+    }
+    subvalue = value.slice(0, min);
+    eat(subvalue)({
+      type: 'text',
+      value: subvalue
+    });
+  }
+}

package/dist/esm/serializers/remarkAssertParents.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = remarkUnwrapInvalidNest;
+var _isEmpty2 = _interopRequireDefault(require("lodash/isEmpty"));
+var _nth2 = _interopRequireDefault(require("lodash/nth"));
+var _last2 = _interopRequireDefault(require("lodash/last"));
+var _concat2 = _interopRequireDefault(require("lodash/concat"));
+var _unistUtilVisitParents = _interopRequireDefault(require("unist-util-visit-parents"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/**
+ * remarkUnwrapInvalidNest
+ *
+ * Some MDAST node types can only be nested within specific node types - for
+ * example, a paragraph can't be nested within another paragraph, and a heading
+ * can't be nested in a "strong" type node. This kind of invalid MDAST can be
+ * generated by rehype-remark from invalid HTML.
+ *
+ * This plugin finds instances of invalid nesting, and unwraps the invalidly
+ * nested nodes as far up the parental line as necessary, splitting parent nodes
+ * along the way. The resulting node has no invalidly nested nodes, and all
+ * validly nested nodes retain their ancestry. Nodes that are emptied as a
+ * result of unnesting nodes are removed from the tree.
+ */
+function remarkUnwrapInvalidNest() {
+  return transform;
+  function transform(tree) {
+    const invalidNest = findInvalidNest(tree);
+    if (!invalidNest) return tree;
+    splitTreeAtNest(tree, invalidNest);
+    return transform(tree);
+  }
+
+  /**
+   * visitParents uses unist-util-visit-parent to check every node in the
+   * tree while having access to every ancestor of the node. This is ideal
+   * for determining whether a block node has an ancestor that should not
+   * contain a block node. Note that it operates in a mutable fashion.
+   */
+  function findInvalidNest(tree) {
+    /**
+     * Node types that are considered "blocks".
+     */
+    const blocks = ['paragraph', 'heading', 'code', 'blockquote', 'list', 'table', 'thematicBreak'];
+
+    /**
+     * Node types that can contain "block" nodes as direct children. We check
+     */
+    const canContainBlocks = ['root', 'blockquote', 'listItem', 'tableCell'];
+    let invalidNest;
+    (0, _unistUtilVisitParents.default)(tree, (node, parents) => {
+      const parentType = !(0, _isEmpty2.default)(parents) && (0, _last2.default)(parents).type;
+      const isInvalidNest = blocks.includes(node.type) && !canContainBlocks.includes(parentType);
+      if (isInvalidNest) {
+        invalidNest = (0, _concat2.default)(parents, node);
+        return false;
+      }
+    });
+    return invalidNest;
+  }
+  function splitTreeAtNest(tree, nest) {
+    const grandparent = (0, _nth2.default)(nest, -3) || tree;
+    const parent = (0, _nth2.default)(nest, -2);
+    const node = (0, _last2.default)(nest);
+    const splitIndex = grandparent.children.indexOf(parent);
+    const splitChildren = grandparent.children;
+    const splitChildIndex = parent.children.indexOf(node);
+    const childrenBefore = parent.children.slice(0, splitChildIndex);
+    const childrenAfter = parent.children.slice(splitChildIndex + 1);
+    const nodeBefore = !(0, _isEmpty2.default)(childrenBefore) && _objectSpread(_objectSpread({}, parent), {}, {
+      children: childrenBefore
+    });
+    const nodeAfter = !(0, _isEmpty2.default)(childrenAfter) && _objectSpread(_objectSpread({}, parent), {}, {
+      children: childrenAfter
+    });
+    const childrenToInsert = [nodeBefore, node, nodeAfter].filter(val => !(0, _isEmpty2.default)(val));
+    const beforeChildren = splitChildren.slice(0, splitIndex);
+    const afterChildren = splitChildren.slice(splitIndex + 1);
+    const newChildren = (0, _concat2.default)(beforeChildren, childrenToInsert, afterChildren);
+    grandparent.children = newChildren;
+  }
+}