@tinacms/mdx 0.0.0-20220718185604 → 0.60.3

package/dist/mdx.es.js

@@ -0,0 +1,1092 @@
+import { remark } from "remark";
+import remarkMdx from "remark-mdx";
+import { visit } from "unist-util-visit";
+import flatten from "lodash.flatten";
+import { toMarkdown } from "mdast-util-to-markdown";
+import { mdxJsxToMarkdown } from "mdast-util-mdx-jsx";
+import { format } from "prettier";
+const extractAttributes = (attributes, fields, imageCallback) => {
+  const properties = {};
+  attributes.forEach((attribute) => {
+    assertType(attribute, "mdxJsxAttribute");
+    const field = fields.find((field2) => field2.name === attribute.name);
+    if (!field) {
+      throw new Error(`Unable to find field definition for property "${attribute.name}"`);
+    }
+    properties[attribute.name] = extractAttribute(attribute, field, imageCallback);
+  });
+  return properties;
+};
+const extractAttribute = (attribute, field, imageCallback) => {
+  switch (field.type) {
+    case "boolean":
+    case "number":
+      return extractScalar(extractExpression(attribute), field);
+    case "datetime":
+    case "string":
+      if (field.list) {
+        return extractScalar(extractExpression(attribute), field);
+      } else {
+        return extractString(attribute, field);
+      }
+    case "image":
+      if (field.list) {
+        const values = extractScalar(extractExpression(attribute), field);
+        return values.split(",").map((value) => imageCallback(value));
+      } else {
+        const value = extractString(attribute, field);
+        return imageCallback(value);
+      }
+    case "reference":
+      if (field.list) {
+        return extractScalar(extractExpression(attribute), field);
+      } else {
+        return extractString(attribute, field);
+      }
+    case "object":
+      return extractObject(extractExpression(attribute), field);
+    case "rich-text":
+      const JSXString = extractJSXFragment(extractExpression(attribute), attribute, field);
+      if (JSXString) {
+        return parseMDX(JSXString, field, imageCallback);
+      } else {
+        return {};
+      }
+    default:
+      throw new Error(`Extract attribute: Unhandled field type ${field.type}`);
+  }
+};
+const extractScalar = (attribute, field) => {
+  if (field.list) {
+    assertType(attribute.expression, "ArrayExpression");
+    return attribute.expression.elements.map((element) => {
+      assertHasType(element);
+      assertType(element, "Literal");
+      return element.value;
+    });
+  } else {
+    assertType(attribute.expression, "Literal");
+    return attribute.expression.value;
+  }
+};
+const extractObject = (attribute, field) => {
+  if (field.list) {
+    assertType(attribute.expression, "ArrayExpression");
+    return attribute.expression.elements.map((element) => {
+      assertHasType(element);
+      assertType(element, "ObjectExpression");
+      return extractObjectExpression(element, field);
+    });
+  } else {
+    assertType(attribute.expression, "ObjectExpression");
+    return extractObjectExpression(attribute.expression, field);
+  }
+};
+const extractObjectExpression = (expression, field) => {
+  const properties = {};
+  expression.properties.forEach((property) => {
+    assertType(property, "Property");
+    const { key, value } = extractKeyValue(property, field);
+    properties[key] = value;
+  });
+  return properties;
+};
+const getField = (objectField, name) => {
+  if (objectField.fields) {
+    if (typeof objectField.fields === "string") {
+      throw new Error("Global templates not supported");
+    }
+    return objectField.fields.find((f) => f.name === name);
+  }
+};
+const extractJSXFragment = (attribute, baseAttribute, field) => {
+  if (field.list)
+    ;
+  else {
+    if (attribute.expression.type === "JSXFragment") {
+      assertHasType(attribute.expression);
+      if (attribute.expression.children[0]) {
+        const firstChild = attribute.expression.children[0];
+        if (attribute.expression.children[0].type === "JSXText") {
+          const child = firstChild;
+          return child.value.trim();
+        }
+      }
+    }
+  }
+  throwError(field);
+};
+const extractKeyValue = (property, parentField) => {
+  assertType(property.key, "Identifier");
+  const key = property.key.name;
+  const field = getField(parentField, key);
+  if ((field == null ? void 0 : field.type) === "object") {
+    if (field.list) {
+      assertType(property.value, "ArrayExpression");
+      const value = property.value.elements.map((element) => {
+        assertHasType(element);
+        assertType(element, "ObjectExpression");
+        return extractObjectExpression(element, field);
+      });
+      return { key, value };
+    } else {
+      assertType(property.value, "ObjectExpression");
+      const value = extractObjectExpression(property.value, field);
+      return { key, value };
+    }
+  } else {
+    assertType(property.value, "Literal");
+    return { key, value: property.value.value };
+  }
+};
+const extractStatement = (attribute) => {
+  var _a, _b;
+  const body = (_b = (_a = attribute.data) == null ? void 0 : _a.estree) == null ? void 0 : _b.body;
+  if (body) {
+    if (body[0]) {
+      assertType(body[0], "ExpressionStatement");
+      return body[0];
+    }
+  }
+  throw new Error(`Unable to extract body from expression`);
+};
+const extractString = (attribute, field) => {
+  if (attribute.type === "mdxJsxAttribute") {
+    if (typeof attribute.value === "string") {
+      return attribute.value;
+    }
+  }
+  return extractScalar(extractExpression(attribute), field);
+};
+const extractExpression = (attribute) => {
+  assertType(attribute, "mdxJsxAttribute");
+  assertHasType(attribute.value);
+  assertType(attribute.value, "mdxJsxAttributeValueExpression");
+  return extractStatement(attribute.value);
+};
+function assertType(val, type) {
+  if (val.type !== type) {
+    throw new Error(`Expected type to be ${type} but received ${val.type}. ${MDX_PARSE_ERROR_MSG}`);
+  }
+}
+function assertHasType(val) {
+  if (val) {
+    if (typeof val !== "string") {
+      return;
+    }
+  }
+  throw new Error(`Expect value to be an object with property "type"`);
+}
+const throwError = (field) => {
+  throw new Error(`Unexpected expression for field "${field.name}"${field.list ? ' with "list": true' : ""}`);
+};
+function mdxJsxElement(node, field, imageCallback) {
+  var _a;
+  const template = (_a = field.templates) == null ? void 0 : _a.find((template2) => {
+    const templateName = typeof template2 === "string" ? template2 : template2.name;
+    return templateName === node.name;
+  });
+  if (typeof template === "string") {
+    throw new Error("Global templates not yet supported");
+  }
+  if (!template) {
+    const string = toMarkdown({ type: "root", children: [node] }, {
+      extensions: [mdxJsxToMarkdown()],
+      listItemIndent: "one"
+    });
+    return {
+      type: node.type === "mdxJsxFlowElement" ? "html" : "html_inline",
+      value: string.trim(),
+      children: [{ type: "text", text: "" }]
+    };
+  }
+  if (template.match) {
+    const value = node.children[0].value;
+    if (node.type === "mdxJsxFlowElement") {
+      return {
+        type: node.type,
+        name: node.name,
+        children: [{ type: "text", text: "" }],
+        props: { text: value }
+      };
+    } else {
+      return {
+        type: node.type,
+        name: node.name,
+        children: [{ type: "text", text: "" }],
+        props: { text: value }
+      };
+    }
+  }
+  const props = extractAttributes(node.attributes, template.fields, imageCallback);
+  const childField = template.fields.find((field2) => field2.name === "children");
+  if (childField) {
+    const childProps = remarkToSlate(node, childField, imageCallback);
+    props.children = childProps;
+  }
+  return {
+    type: node.type,
+    name: node.name,
+    children: [{ type: "text", text: "" }],
+    props
+  };
+}
+const remarkToSlate = (root, field, imageCallback) => {
+  const content = (content2) => {
+    switch (content2.type) {
+      case "blockquote":
+        const children = [];
+        content2.children.map((child) => {
+          const inlineElements = unwrapBlockContent(child);
+          inlineElements.forEach((child2) => {
+            children.push(child2);
+          });
+        });
+        return {
+          type: "blockquote",
+          children
+        };
+      case "heading":
+        return heading(content2);
+      case "code":
+        return code(content2);
+      case "paragraph":
+        return paragraph(content2);
+      case "mdxJsxFlowElement":
+        return mdxJsxElement(content2, field, imageCallback);
+      case "thematicBreak":
+        return {
+          type: "hr",
+          children: [{ type: "text", text: "" }]
+        };
+      case "listItem":
+        return {
+          type: "li",
+          children: [
+            {
+              type: "lic",
+              children: flatten(content2.children.map((child) => unwrapBlockContent(child)))
+            }
+          ]
+        };
+      case "list":
+        return list(content2);
+      case "html":
+        return html(content2);
+      case "mdxjsEsm":
+        throw new Error(`Unexpected expression ${content2.value} ${MDX_PARSE_ERROR_MSG}`);
+      default:
+        throw new Error(`Content: ${content2.type} is not yet supported`);
+    }
+  };
+  const html = (content2) => {
+    return {
+      type: "html",
+      value: content2.value,
+      children: [{ type: "text", text: "" }]
+    };
+  };
+  const html_inline = (content2) => {
+    return {
+      type: "html_inline",
+      value: content2.value,
+      children: [{ type: "text", text: "" }]
+    };
+  };
+  const list = (content2) => {
+    return {
+      type: content2.ordered ? "ol" : "ul",
+      children: content2.children.map((child) => listItem(child))
+    };
+  };
+  const listItem = (content2) => {
+    return {
+      type: "li",
+      children: content2.children.map((child) => {
+        switch (child.type) {
+          case "list":
+            return list(child);
+          case "heading":
+          case "paragraph":
+            return {
+              type: "lic",
+              children: flatten(child.children.map((child2) => phrasingContent(child2)))
+            };
+          case "blockquote": {
+            return {
+              ...blockquote(child),
+              type: "lic"
+            };
+          }
+          case "mdxJsxFlowElement":
+            return {
+              type: "lic",
+              children: [
+                mdxJsxElement({ ...child, type: "mdxJsxTextElement" }, field, imageCallback)
+              ]
+            };
+          case "code":
+          case "thematicBreak":
+          case "table":
+          case "html":
+            throw new Error(`${content2.type} inside list item is not supported`);
+          default:
+            throw new Error(`Unknown list item of type ${content2.type}`);
+        }
+      })
+    };
+  };
+  const unwrapBlockContent = (content2) => {
+    const flattenPhrasingContent = (children) => {
+      const children2 = children.map((child) => phrasingContent(child));
+      return flatten(Array.isArray(children2) ? children2 : [children2]);
+    };
+    switch (content2.type) {
+      case "heading":
+      case "paragraph":
+        return flattenPhrasingContent(content2.children);
+      default:
+        throw new Error(`UnwrapBlock: Unknown block content of type ${content2.type}`);
+    }
+  };
+  const code = (content2) => {
+    const extra = {};
+    if (content2.lang)
+      extra["lang"] = content2.lang;
+    return {
+      type: "code_block",
+      ...extra,
+      value: content2.value,
+      children: [{ type: "text", text: "" }]
+    };
+  };
+  const link = (content2) => {
+    return {
+      type: "a",
+      url: content2.url,
+      title: content2.title,
+      children: flatten(content2.children.map((child) => staticPhrasingContent(child)))
+    };
+  };
+  const heading = (content2) => {
+    return {
+      type: ["h1", "h2", "h3", "h4", "h5", "h6"][content2.depth - 1],
+      children: flatten(content2.children.map(phrasingContent))
+    };
+  };
+  const staticPhrasingContent = (content2) => {
+    switch (content2.type) {
+      case "mdxJsxTextElement":
+        return mdxJsxElement(content2, field, imageCallback);
+      case "text":
+        return text(content2);
+      case "inlineCode":
+      case "emphasis":
+      case "image":
+      case "strong":
+        return phrashingMark(content2);
+      default:
+        throw new Error(`StaticPhrasingContent: ${content2.type} is not yet supported`);
+    }
+  };
+  const phrasingContent = (content2) => {
+    switch (content2.type) {
+      case "text":
+        return text(content2);
+      case "link":
+        return link(content2);
+      case "image":
+        return image(content2);
+      case "mdxJsxTextElement":
+        return mdxJsxElement(content2, field, imageCallback);
+      case "emphasis":
+        return phrashingMark(content2);
+      case "strong":
+        return phrashingMark(content2);
+      case "break":
+        return breakContent();
+      case "inlineCode":
+        return phrashingMark(content2);
+      case "html":
+        return html_inline(content2);
+      default:
+        throw new Error(`PhrasingContent: ${content2.type} is not yet supported`);
+    }
+  };
+  const breakContent = () => {
+    return {
+      type: "break",
+      children: [
+        {
+          type: "text",
+          text: ""
+        }
+      ]
+    };
+  };
+  const phrashingMark = (node, marks = []) => {
+    const accum = [];
+    switch (node.type) {
+      case "emphasis": {
+        const children = flatten(node.children.map((child) => phrashingMark(child, [...marks, "italic"])));
+        children.forEach((child) => {
+          accum.push(child);
+        });
+        break;
+      }
+      case "inlineCode": {
+        const markProps2 = {};
+        marks.forEach((mark) => markProps2[mark] = true);
+        accum.push({
+          type: "text",
+          text: node.value,
+          code: true,
+          ...markProps2
+        });
+        break;
+      }
+      case "strong": {
+        const children = flatten(node.children.map((child) => phrashingMark(child, [...marks, "bold"])));
+        children.forEach((child) => {
+          accum.push(child);
+        });
+        break;
+      }
+      case "image": {
+        accum.push(image(node));
+        break;
+      }
+      case "link": {
+        const children = flatten(node.children.map((child) => phrashingMark(child, marks)));
+        accum.push({ type: "a", url: node.url, title: node.title, children });
+        break;
+      }
+      case "text":
+        const markProps = {};
+        marks.forEach((mark) => markProps[mark] = true);
+        accum.push({ type: "text", text: node.value, ...markProps });
+        break;
+      default:
+        throw new Error(`Unexpected inline element of type ${node.type}`);
+    }
+    return accum;
+  };
+  const image = (content2) => {
+    return {
+      type: "img",
+      url: imageCallback(content2.url),
+      alt: content2.alt,
+      caption: content2.title,
+      children: [{ type: "text", text: "" }]
+    };
+  };
+  const text = (content2) => {
+    return {
+      type: "text",
+      text: content2.value
+    };
+  };
+  const blockquote = (content2) => {
+    const children = [];
+    content2.children.map((child) => {
+      const inlineElements = unwrapBlockContent(child);
+      inlineElements.forEach((child2) => {
+        children.push(child2);
+      });
+    });
+    return {
+      type: "blockquote",
+      children
+    };
+  };
+  const paragraph = (content2) => {
+    const children = flatten(content2.children.map(phrasingContent));
+    if (children.length === 1) {
+      if (children[0]) {
+        if (children[0].type === "html_inline") {
+          return {
+            ...children[0],
+            type: "html"
+          };
+        }
+      }
+    }
+    return {
+      type: "p",
+      children
+    };
+  };
+  return {
+    type: "root",
+    children: root.children.map((child) => content(child))
+  };
+};
+const markdownToAst = (value, field) => {
+  var _a;
+  const templatesWithMatchers = (_a = field.templates) == null ? void 0 : _a.filter((template) => template.match);
+  let preprocessedString = value;
+  templatesWithMatchers == null ? void 0 : templatesWithMatchers.forEach((template) => {
+    if (typeof template === "string") {
+      throw new Error("Global templates are not supported");
+    }
+    if (template.match) {
+      preprocessedString = preprocessedString.replaceAll(template.match.start, `<${template.name}>\``);
+      preprocessedString = preprocessedString.replaceAll(template.match.end, `\`</${template.name}>`);
+    }
+  });
+  const tree = remark().use(remarkMdx).parse(preprocessedString);
+  if (!tree) {
+    throw new Error("Error parsing markdown");
+  }
+  visit(tree, (node) => {
+    delete node.position;
+  });
+  return tree;
+};
+const MDX_PARSE_ERROR_MSG = "TinaCMS supports a stricter version of markdown and a subset of MDX - learn more: https://tina.io/docs/editing/mdx/#differences-from-other-mdx-implementations";
+const parseMDX = (value, field, imageCallback) => {
+  let tree;
+  try {
+    tree = markdownToAst(value, field);
+  } catch (e) {
+    if (e.position) {
+      throw new Error(`Unable to parse markdown at line: ${e.position.start.line}, column: ${e.position.start.column}. ${MDX_PARSE_ERROR_MSG}`);
+    }
+    throw new Error(`Unable to parse markdown, ${MDX_PARSE_ERROR_MSG}`);
+  }
+  if (tree) {
+    return remarkToSlate(tree, field, imageCallback);
+  } else {
+    return { type: "root", children: [] };
+  }
+};
+const stringifyPropsInline = (element, field, imageCallback) => {
+  return stringifyProps(element, field, true, imageCallback);
+};
+function stringifyProps(element, parentField, flatten2, imageCallback) {
+  var _a;
+  const attributes = [];
+  const children = [];
+  const template = (_a = parentField.templates) == null ? void 0 : _a.find((template2) => {
+    if (typeof template2 === "string") {
+      throw new Error("Global templates not supported");
+    }
+    return template2.name === element.name;
+  });
+  if (!template || typeof template === "string") {
+    throw new Error(`Unable to find template for JSX element ${element.name}`);
+  }
+  Object.entries(element.props).forEach(([name, value]) => {
+    const field = template.fields.find((field2) => field2.name === name);
+    if (!field) {
+      if (name === "children") {
+        return;
+      }
+      throw new Error(`No field definition found for property ${name}`);
+    }
+    switch (field.type) {
+      case "reference":
+        if (field.list) {
+          if (Array.isArray(value)) {
+            attributes.push({
+              type: "mdxJsxAttribute",
+              name,
+              value: {
+                type: "mdxJsxAttributeValueExpression",
+                value: `[${value.map((item) => `"${item}"`).join(", ")}]`
+              }
+            });
+          }
+        } else {
+          if (typeof value === "string") {
+            attributes.push({
+              type: "mdxJsxAttribute",
+              name,
+              value
+            });
+          }
+        }
+        break;
+      case "datetime":
+      case "string":
+        if (field.list) {
+          if (Array.isArray(value)) {
+            attributes.push({
+              type: "mdxJsxAttribute",
+              name,
+              value: {
+                type: "mdxJsxAttributeValueExpression",
+                value: `[${value.map((item) => `"${item}"`).join(", ")}]`
+              }
+            });
+          }
+        } else {
+          attributes.push({
+            type: "mdxJsxAttribute",
+            name,
+            value
+          });
+        }
+        break;
+      case "image":
+        if (field.list) {
+          if (Array.isArray(value)) {
+            attributes.push({
+              type: "mdxJsxAttribute",
+              name,
+              value: {
+                type: "mdxJsxAttributeValueExpression",
+                value: `[${value.map((item) => `"${imageCallback(item)}"`).join(", ")}]`
+              }
+            });
+          }
+        } else {
+          attributes.push({
+            type: "mdxJsxAttribute",
+            name,
+            value: imageCallback(value)
+          });
+        }
+        break;
+      case "number":
+      case "boolean":
+        if (field.list) {
+          attributes.push({
+            type: "mdxJsxAttribute",
+            name,
+            value: {
+              type: "mdxJsxAttributeValueExpression",
+              value: `[${value.map((item) => `${item}`).join(", ")}]`
+            }
+          });
+        } else {
+          attributes.push({
+            type: "mdxJsxAttribute",
+            name,
+            value: {
+              type: "mdxJsxAttributeValueExpression",
+              value
+            }
+          });
+        }
+        break;
+      case "object":
+        attributes.push({
+          type: "mdxJsxAttribute",
+          name,
+          value: {
+            type: "mdxJsxAttributeValueExpression",
+            value: stringifyObj(value, flatten2)
+          }
+        });
+        break;
+      case "rich-text":
+        if (typeof value === "string") {
+          throw new Error(`Unexpected string for rich-text, ensure the value has been properly parsed`);
+        }
+        if (field.list) {
+          throw new Error(`Rich-text list is not supported`);
+        } else {
+          const joiner = flatten2 ? " " : "\n";
+          let val = "";
+          if (field.name === "children") {
+            const root = rootElement(value, field, imageCallback);
+            root.children.forEach((child) => {
+              children.push(child);
+            });
+            return;
+          } else {
+            const stringValue = stringifyMDX(value, field, imageCallback);
+            val = stringValue.trim().split("\n").map((str) => `  ${str.trim()}`).join(joiner);
+          }
+          if (flatten2) {
+            attributes.push({
+              type: "mdxJsxAttribute",
+              name,
+              value: {
+                type: "mdxJsxAttributeValueExpression",
+                value: `<>${val.trim()}</>`
+              }
+            });
+          } else {
+            attributes.push({
+              type: "mdxJsxAttribute",
+              name,
+              value: {
+                type: "mdxJsxAttributeValueExpression",
+                value: `<>
+${val}
+</>`
+              }
+            });
+          }
+        }
+        break;
+      default:
+        throw new Error(`Stringify props: ${field.type} not yet supported`);
+    }
+  });
+  if (template.match) {
+    if (attributes[0] && typeof attributes[0].value === "string") {
+      return {
+        attributes: [],
+        children: [{ type: "inlineCode", value: attributes[0].value }]
+      };
+    }
+  }
+  return { attributes, children };
+}
+function stringifyObj(obj, flatten2) {
+  const dummyFunc = `const dummyFunc = `;
+  const res = format(`${dummyFunc}${JSON.stringify(obj)}`, {
+    parser: "acorn",
+    trailingComma: "none",
+    semi: false
+  }).trim().replace(dummyFunc, "");
+  return flatten2 ? res.replaceAll("\n", "").replaceAll("  ", " ") : res;
+}
+const matches = (a, b) => {
+  return a.some((v) => b.includes(v));
+};
+const replaceLinksWithTextNodes = (content) => {
+  const newItems = [];
+  content.forEach((item) => {
+    if (item.type === "a") {
+      if (item.children.length === 1) {
+        const firstChild = item.children[0];
+        if ((firstChild == null ? void 0 : firstChild.type) === "text") {
+          newItems.push({
+            ...firstChild,
+            linkifyTextNode: (a) => {
+              return {
+                type: "link",
+                url: item.url,
+                title: item.title,
+                children: [
+                  {
+                    type: "text",
+                    value: a.value
+                  }
+                ]
+              };
+            }
+          });
+        } else {
+          newItems.push(item);
+        }
+      } else {
+        newItems.push(item);
+      }
+    } else {
+      newItems.push(item);
+    }
+  });
+  return newItems;
+};
+const inlineElementExceptLink = (content, field, imageCallback) => {
+  switch (content.type) {
+    case "a":
+      throw new Error(`Unexpected node of type "a", link elements should be processed after all inline elements have resolved`);
+    case "img":
+      return {
+        type: "image",
+        url: imageCallback(content.url),
+        alt: content.alt,
+        title: content.caption
+      };
+    case "break":
+      return {
+        type: "break"
+      };
+    case "mdxJsxTextElement": {
+      const { attributes, children } = stringifyPropsInline(content, field, imageCallback);
+      return {
+        type: "mdxJsxTextElement",
+        name: content.name,
+        attributes,
+        children
+      };
+    }
+    case "html_inline": {
+      return {
+        type: "html",
+        value: content.value
+      };
+    }
+    default:
+      if (!content.type && typeof content.text === "string") {
+        return {
+          type: "text",
+          value: content.text
+        };
+      }
+      throw new Error(`InlineElement: ${content.type} is not supported`);
+  }
+};
+const eat = (c, field, imageCallback) => {
+  const content = replaceLinksWithTextNodes(c);
+  const first = content[0];
+  if (!first) {
+    return [];
+  }
+  if (first && (first == null ? void 0 : first.type) !== "text") {
+    return [
+      inlineElementExceptLink(first, field, imageCallback),
+      ...eat(content.slice(1), field, imageCallback)
+    ];
+  }
+  const marks = getMarks(first);
+  if (marks.length === 0) {
+    if (first.linkifyTextNode) {
+      return [
+        first.linkifyTextNode({ type: "text", value: first.text }),
+        ...eat(content.slice(1), field, imageCallback)
+      ];
+    } else {
+      return [
+        { type: "text", value: first.text },
+        ...eat(content.slice(1), field, imageCallback)
+      ];
+    }
+  }
+  let nonMatchingSiblingIndex = 0;
+  if (content.slice(1).every((content2, index) => {
+    if (matches(marks, getMarks(content2))) {
+      return true;
+    } else {
+      nonMatchingSiblingIndex = index;
+      return false;
+    }
+  })) {
+    nonMatchingSiblingIndex = content.length - 1;
+  }
+  const matchingSiblings = content.slice(1, nonMatchingSiblingIndex + 1);
+  const markCounts = {};
+  marks.forEach((mark) => {
+    let count2 = 1;
+    matchingSiblings.every((sibling, index) => {
+      if (getMarks(sibling).includes(mark)) {
+        count2 = index + 1;
+        return true;
+      }
+    });
+    markCounts[mark] = count2;
+  });
+  let count = 0;
+  let markToProcess = null;
+  Object.entries(markCounts).forEach(([mark, markCount]) => {
+    const m = mark;
+    if (markCount > count) {
+      count = markCount;
+      markToProcess = m;
+    }
+  });
+  if (!markToProcess) {
+    return [
+      {
+        type: "text",
+        value: first.text
+      },
+      ...eat(content.slice(1), field, imageCallback)
+    ];
+  }
+  if (markToProcess === "inlineCode") {
+    if (nonMatchingSiblingIndex) {
+      throw new Error(`Marks inside inline code are not supported`);
+    }
+    return [
+      {
+        type: markToProcess,
+        value: first.text
+      },
+      ...eat(content.slice(nonMatchingSiblingIndex + 1), field, imageCallback)
+    ];
+  }
+  return [
+    {
+      type: markToProcess,
+      children: eat([
+        ...[first, ...matchingSiblings].map((sibling) => cleanNode(sibling, markToProcess))
+      ], field, imageCallback)
+    },
+    ...eat(content.slice(nonMatchingSiblingIndex + 1), field, imageCallback)
+  ];
+};
+const cleanNode = (node, mark) => {
+  if (!mark) {
+    return node;
+  }
+  const cleanedNode = {};
+  const markToClear = {
+    strong: "bold",
+    emphasis: "italic",
+    inlineCode: "code"
+  }[mark];
+  Object.entries(node).map(([key, value]) => {
+    if (key !== markToClear) {
+      cleanedNode[key] = value;
+    }
+  });
+  if (node.linkifyTextNode) {
+    cleanedNode.callback = node.linkifyTextNode;
+  }
+  return cleanedNode;
+};
+const stringifyMDX = (value, field, imageCallback) => {
+  var _a;
+  const res = toMarkdown(rootElement(value, field, imageCallback), {
+    extensions: [mdxJsxToMarkdown()],
+    listItemIndent: "one"
+  });
+  const templatesWithMatchers = (_a = field.templates) == null ? void 0 : _a.filter((template) => template.match);
+  let preprocessedString = res;
+  templatesWithMatchers == null ? void 0 : templatesWithMatchers.forEach((template) => {
+    if (typeof template === "string") {
+      throw new Error("Global templates are not supported");
+    }
+    if (template.match) {
+      preprocessedString = preprocessedString.replaceAll(`<${template.name}>\``, `${template.match.start} `);
+      preprocessedString = preprocessedString.replaceAll(`\`</${template.name}>`, ` ${template.match.end}`);
+    }
+  });
+  return preprocessedString;
+};
+const rootElement = (content, field, imageCallback) => {
+  const children = [];
+  content.children.forEach((child) => {
+    const value = blockElement(child, field, imageCallback);
+    if (value) {
+      children.push(value);
+    }
+  });
+  return {
+    type: "root",
+    children
+  };
+};
+const blockElement = (content, field, imageCallback) => {
+  switch (content.type) {
+    case "h1":
+    case "h2":
+    case "h3":
+    case "h4":
+    case "h5":
+    case "h6":
+      return {
+        type: "heading",
+        depth: { h1: 1, h2: 2, h3: 3, h4: 4, h5: 5, h6: 6 }[content.type],
+        children: eat(content.children, field, imageCallback)
+      };
+    case "p":
+      if (content.children.length === 1) {
+        const onlyChild = content.children[0];
+        if (onlyChild && onlyChild.type === "text" && onlyChild.text === "") {
+          return null;
+        }
+      }
+      return {
+        type: "paragraph",
+        children: eat(content.children, field, imageCallback)
+      };
+    case "code_block":
+      return {
+        type: "code",
+        lang: content.lang,
+        value: content.value
+      };
+    case "mdxJsxFlowElement":
+      const { children, attributes } = stringifyProps(content, field, false, imageCallback);
+      return {
+        type: "mdxJsxFlowElement",
+        name: content.name,
+        attributes,
+        children
+      };
+    case "blockquote":
+      return {
+        type: "blockquote",
+        children: [
+          {
+            type: "paragraph",
+            children: eat(content.children, field, imageCallback)
+          }
+        ]
+      };
+    case "hr":
+      return {
+        type: "thematicBreak"
+      };
+    case "ol":
+    case "ul":
+      return {
+        type: "list",
+        ordered: content.type === "ol",
+        spread: false,
+        children: content.children.map((child) => listItemElement(child, field, imageCallback))
+      };
+    case "html": {
+      return {
+        type: "html",
+        value: content.value
+      };
+    }
+    default:
+      throw new Error(`BlockElement: ${content.type} is not yet supported`);
+  }
+};
+const listItemElement = (content, field, imageCallback) => {
+  return {
+    type: "listItem",
+    spread: false,
+    children: content.children.map((child) => {
+      if (child.type === "lic") {
+        return {
+          type: "paragraph",
+          children: eat(child.children, field, imageCallback)
+        };
+      }
+      return blockContentElement(child, field, imageCallback);
+    })
+  };
+};
+const blockContentElement = (content, field, imageCallback) => {
+  switch (content.type) {
+    case "blockquote":
+      return {
+        type: "blockquote",
+        children: content.children.map((child) => blockContentElement(child, field, imageCallback))
+      };
+    case "p":
+      return {
+        type: "paragraph",
+        children: eat(content.children, field, imageCallback)
+      };
+    case "ol":
+    case "ul":
+      return {
+        type: "list",
+        ordered: content.type === "ol",
+        spread: false,
+        children: content.children.map((child) => listItemElement(child, field, imageCallback))
+      };
+    default:
+      throw new Error(`BlockContentElement: ${content.type} is not yet supported`);
+  }
+};
+const getMarks = (content) => {
+  const marks = [];
+  if (content.type !== "text") {
+    return [];
+  }
+  if (content.bold) {
+    marks.push("strong");
+  }
+  if (content.italic) {
+    marks.push("emphasis");
+  }
+  if (content.code) {
+    marks.push("inlineCode");
+  }
+  return marks;
+};
+export { parseMDX, stringifyMDX };