@portabletext/markdown 1.0.0

package/dist/index.js

@@ -0,0 +1,1098 @@
+import { compileSchema, defineSchema, isTextBlock, isSpan } from "@portabletext/schema";
+import { isPortableTextListItemBlock, isPortableTextToolkitSpan, isPortableTextBlock, isPortableTextToolkitTextNode, buildMarksTree, spanToPlainText } from "@portabletext/toolkit";
+import markdownit from "markdown-it";
+function defaultKeyGenerator() {
+  return randomKey(12);
+}
+const getByteHexTable = /* @__PURE__ */ (() => {
+  let table;
+  return () => {
+    if (table)
+      return table;
+    table = [];
+    for (let i = 0; i < 256; ++i)
+      table[i] = (i + 256).toString(16).slice(1);
+    return table;
+  };
+})();
+function whatwgRNG(length = 16) {
+  const rnds8 = new Uint8Array(length);
+  return crypto.getRandomValues(rnds8), rnds8;
+}
+function randomKey(length) {
+  const table = getByteHexTable();
+  return whatwgRNG(length).reduce((str, n) => str + table[n], "").slice(0, length);
+}
+const schema = compileSchema(defineSchema({}));
+function buildListIndexMap(blocks) {
+  const levelIndexMaps = /* @__PURE__ */ new Map(), listIndexMap = /* @__PURE__ */ new Map();
+  let previousListItem;
+  for (let blockIndex = 0; blockIndex < blocks.length; blockIndex++) {
+    const block = blocks.at(blockIndex);
+    if (block === void 0)
+      continue;
+    if (block._key || (block._key = defaultKeyGenerator()), !isTextBlock({ schema }, block)) {
+      levelIndexMaps.clear(), previousListItem = void 0;
+      continue;
+    }
+    if (block.listItem === void 0 || block.level === void 0) {
+      levelIndexMaps.clear(), previousListItem = void 0;
+      continue;
+    }
+    if (!previousListItem) {
+      const levelIndexMap2 = levelIndexMaps.get(block.listItem) ?? /* @__PURE__ */ new Map();
+      levelIndexMap2.set(block.level, 1), levelIndexMaps.set(block.listItem, levelIndexMap2), listIndexMap.set(block._key, 1), previousListItem = {
+        listItem: block.listItem,
+        level: block.level
+      };
+      continue;
+    }
+    if (previousListItem.listItem === block.listItem && previousListItem.level < block.level) {
+      const levelIndexMap2 = levelIndexMaps.get(block.listItem) ?? /* @__PURE__ */ new Map();
+      levelIndexMap2.set(block.level, 1), levelIndexMaps.set(block.listItem, levelIndexMap2), listIndexMap.set(block._key, 1), previousListItem = {
+        listItem: block.listItem,
+        level: block.level
+      };
+      continue;
+    }
+    levelIndexMaps.forEach((levelIndexMap2, listItem) => {
+      if (listItem === block.listItem)
+        return;
+      const levelsToDelete = [];
+      levelIndexMap2.forEach((_, level) => {
+        level >= block.level && levelsToDelete.push(level);
+      }), levelsToDelete.forEach((level) => {
+        levelIndexMap2.delete(level);
+      });
+    });
+    const levelIndexMap = levelIndexMaps.get(block.listItem) ?? /* @__PURE__ */ new Map(), levelCounter = levelIndexMap.get(block.level) ?? 0;
+    levelIndexMap.set(block.level, levelCounter + 1), levelIndexMaps.set(block.listItem, levelIndexMap), listIndexMap.set(block._key, levelCounter + 1), previousListItem = {
+      listItem: block.listItem,
+      level: block.level
+    };
+  }
+  return listIndexMap;
+}
+const createRenderNode = (renderers, listIndexMap) => {
+  function renderNode(options) {
+    const { node, index, isInline } = options;
+    return isPortableTextListItemBlock(node) ? renderListItem(node, index) : isPortableTextToolkitSpan(node) ? renderSpan(node) : isPortableTextBlock(node) ? renderBlock(node, index, isInline) : isPortableTextToolkitTextNode(node) ? renderText(node) : renderCustomBlock(node, index, isInline);
+  }
+  function renderListItem(node, index) {
+    const renderer = renderers.listItem, itemHandler = (typeof renderer == "function" ? renderer : renderer[node.listItem]) || renderers.unknownListItem;
+    let children = buildMarksTree(node).map((child, i) => renderNode({ node: child, isInline: !0, index: i })).join("");
+    if (node.style && node.style !== "normal") {
+      const { listItem: _listItem, ...blockNode } = node;
+      children = renderNode({
+        node: blockNode,
+        index,
+        isInline: !1
+      }), children = children.replace(/\n+$/, "");
+    }
+    return itemHandler({
+      value: node,
+      index,
+      listIndex: node._key ? listIndexMap.get(node._key) : void 0,
+      isInline: !1,
+      renderNode,
+      children
+    });
+  }
+  function renderSpan(node) {
+    const { markDef, markType, markKey } = node, span = renderers.marks[markType] || renderers.unknownMark, children = node.children.map(
+      (child, childIndex) => renderNode({ node: child, index: childIndex, isInline: !0 })
+    );
+    return span({
+      text: spanToPlainText(node),
+      value: markDef,
+      markType,
+      markKey,
+      renderNode,
+      children: children.join("")
+    });
+  }
+  function renderBlock(node, index, isInline) {
+    const { _key, ...props } = serializeBlock({ node, index, isInline, renderNode }), style = props.node.style || "normal";
+    return ((typeof renderers.block == "function" ? renderers.block : renderers.block[style]) || renderers.unknownBlockStyle)({ ...props, value: props.node, renderNode });
+  }
+  function renderText(node) {
+    return node.text === `
+` ? renderers.hardBreak() : node.text;
+  }
+  function renderCustomBlock(value, index, isInline) {
+    return (renderers.types[value._type] ?? renderers.unknownType)({
+      value,
+      isInline,
+      index,
+      renderNode
+    });
+  }
+  return renderNode;
+};
+function serializeBlock(options) {
+  const { node, index, isInline, renderNode } = options, renderedChildren = buildMarksTree(node).map(
+    (child, i) => renderNode({ node: child, isInline: !0, index: i, renderNode })
+  );
+  return {
+    _key: node._key || defaultKeyGenerator(),
+    children: renderedChildren.join(""),
+    index,
+    isInline,
+    node
+  };
+}
+const DefaultBlockSpacingRenderer = ({
+  current,
+  next
+}) => isPortableTextListItemBlock(current) && isPortableTextListItemBlock(next) ? `
+` : isPortableTextBlock(current) && isPortableTextBlock(next) && current.style === "blockquote" && next.style === "blockquote" ? `
+>
+` : `
+
+`, DefaultHardBreakRenderer = () => `  
+`, DefaultListItemRenderer = ({
+  children,
+  value,
+  listIndex
+}) => {
+  const listStyle = value.listItem || "bullet", level = value.level || 1;
+  return listStyle === "number" ? `${"   ".repeat(level - 1)}${listIndex ?? 1}. ${children}` : `${"   ".repeat(level - 1)}- ${children}`;
+}, DefaultUnknownListItemRenderer = ({
+  children
+}) => `- ${children}
+`, DefaultEmRenderer = ({ children }) => `_${children}_`, DefaultStrongRenderer = ({ children }) => `**${children}**`, DefaultCodeRenderer = ({ children }) => `\`${children}\``, DefaultUnderlineRenderer = ({
+  children
+}) => `<u>${children}</u>`, DefaultStrikeThroughRenderer = ({
+  children
+}) => `~~${children}~~`, DefaultLinkRenderer = ({
+  children,
+  value
+}) => {
+  const href = value?.href || "", title = value?.title || "";
+  if (uriLooksSafe(href)) {
+    if (/["'][^"']*[<>]|[<>][^<>]*["']/.test(href)) {
+      const encodedHref = href.replace(/["<>() ]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+      return `[${children}](${encodedHref})`;
+    }
+    return `[${children}](${href}${title ? ` "${title}"` : ""})`;
+  }
+  return children;
+};
+function uriLooksSafe(uri) {
+  const url = (uri || "").trim(), first = url.charAt(0);
+  if (first === "#" || first === "/")
+    return !0;
+  const colonIndex = url.indexOf(":");
+  if (colonIndex === -1)
+    return !0;
+  const allowedProtocols = ["http", "https", "mailto", "tel"], proto = url.slice(0, colonIndex).toLowerCase();
+  if (allowedProtocols.indexOf(proto) !== -1)
+    return !0;
+  const queryIndex = url.indexOf("?");
+  if (queryIndex !== -1 && colonIndex > queryIndex)
+    return !0;
+  const hashIndex = url.indexOf("#");
+  return hashIndex !== -1 && colonIndex > hashIndex;
+}
+const DefaultUnknownMarkRenderer = ({
+  children
+}) => children, DefaultNormalRenderer = ({
+  children
+}) => !children || children.trim() === "" ? "" : children, DefaultBlockquoteRenderer = ({
+  children
+}) => children ? children.split(`
+`).map((line) => `> ${line}`).join(`
+`) : ">", DefaultH1Renderer = ({ children }) => `# ${children}`, DefaultH2Renderer = ({ children }) => `## ${children}`, DefaultH3Renderer = ({ children }) => `### ${children}`, DefaultH4Renderer = ({ children }) => `#### ${children}`, DefaultH5Renderer = ({ children }) => `##### ${children}`, DefaultH6Renderer = ({ children }) => `###### ${children}`, DefaultUnknownStyleRenderer = ({
+  children
+}) => children ?? "", DefaultCodeBlockRenderer = ({ value }) => `\`\`\`${value.language ?? ""}
+${value.code}
+\`\`\``, DefaultHorizontalRuleRenderer = () => "---", DefaultHtmlRenderer = ({ value }) => value.html, DefaultImageRenderer = ({ value }) => {
+  const alt = value.alt ?? "", title = value.title ? ` "${value.title}"` : "";
+  return `![${alt}](${value.src}${title})`;
+}, DefaultTableRenderer = ({ value, renderNode }) => {
+  const headerRows = value.headerRows || 0, rows = value.rows, lines = [], getCellText = (cellBlocks) => cellBlocks.map(
+    (block, index) => renderNode({
+      node: block,
+      index,
+      isInline: !1,
+      renderNode
+    })
+  ).join(" ").trim();
+  for (let i = 0; i < headerRows; i++) {
+    const row = rows[i];
+    if (row) {
+      const cellTexts = row.cells.map((cell) => getCellText(cell.value));
+      lines.push(`| ${cellTexts.join(" | ")} |`);
+    }
+  }
+  if (headerRows > 0 && rows[0]) {
+    const separators = rows[0].cells.map(() => " --- ");
+    lines.push(`|${separators.join("|")}|`);
+  }
+  for (let i = headerRows; i < rows.length; i++) {
+    const row = rows[i];
+    if (row) {
+      const cellTexts = row.cells.map((cell) => getCellText(cell.value));
+      lines.push(`| ${cellTexts.join(" | ")} |`);
+    }
+  }
+  return lines.join(`
+`);
+}, DefaultUnknownTypeRenderer = ({
+  value,
+  isInline
+}) => {
+  const json = `\`\`\`json
+${JSON.stringify(value, null, 2)}
+\`\`\``;
+  return isInline ? `
+${json}
+` : json;
+}, defaultRenderers = {
+  types: {},
+  block: {
+    normal: DefaultNormalRenderer,
+    blockquote: DefaultBlockquoteRenderer,
+    h1: DefaultH1Renderer,
+    h2: DefaultH2Renderer,
+    h3: DefaultH3Renderer,
+    h4: DefaultH4Renderer,
+    h5: DefaultH5Renderer,
+    h6: DefaultH6Renderer
+  },
+  marks: {
+    em: DefaultEmRenderer,
+    strong: DefaultStrongRenderer,
+    code: DefaultCodeRenderer,
+    underline: DefaultUnderlineRenderer,
+    "strike-through": DefaultStrikeThroughRenderer,
+    link: DefaultLinkRenderer
+  },
+  listItem: DefaultListItemRenderer,
+  hardBreak: DefaultHardBreakRenderer,
+  unknownType: DefaultUnknownTypeRenderer,
+  unknownMark: DefaultUnknownMarkRenderer,
+  unknownListItem: DefaultUnknownListItemRenderer,
+  unknownBlockStyle: DefaultUnknownStyleRenderer
+};
+function portableTextToMarkdown(blocks, options = {}) {
+  const renderers = {
+    block: {
+      ...defaultRenderers.block,
+      ...options.block
+    },
+    listItem: options.listItem ?? defaultRenderers.listItem,
+    marks: {
+      ...defaultRenderers.marks,
+      ...options.marks
+    },
+    types: {
+      ...defaultRenderers.types,
+      ...options.types
+    },
+    hardBreak: options.hardBreak ?? defaultRenderers.hardBreak,
+    unknownType: options.unknownType ?? defaultRenderers.unknownType,
+    unknownBlockStyle: options.unknownBlockStyle ?? defaultRenderers.unknownBlockStyle,
+    unknownListItem: options.unknownListItem ?? defaultRenderers.unknownListItem,
+    unknownMark: options.unknownMark ?? defaultRenderers.unknownMark
+  }, renderBlockSpacing = options.blockSpacing ?? DefaultBlockSpacingRenderer, listIndexMap = buildListIndexMap(blocks), renderNode = createRenderNode(renderers, listIndexMap);
+  return blocks.map((node, index) => {
+    const renderedNode = renderNode({
+      node,
+      index,
+      isInline: !1,
+      renderNode
+    });
+    if (index === blocks.length - 1)
+      return renderedNode;
+    const nextNode = blocks.at(index + 1);
+    if (!nextNode)
+      return renderedNode;
+    const blockSpacing = renderBlockSpacing({
+      current: node,
+      next: nextNode
+    }) ?? `
+
+`;
+    return `${renderedNode}${blockSpacing}`;
+  }).join("");
+}
+const normalStyleDefinition = {
+  name: "normal"
+}, h1StyleDefinition = {
+  name: "h1"
+}, h2StyleDefinition = {
+  name: "h2"
+}, h3StyleDefinition = {
+  name: "h3"
+}, h4StyleDefinition = {
+  name: "h4"
+}, h5StyleDefinition = {
+  name: "h5"
+}, h6StyleDefinition = {
+  name: "h6"
+}, blockquoteStyleDefinition = {
+  name: "blockquote"
+}, defaultOrderedListItemDefinition = {
+  name: "number"
+}, defaultUnorderedListItemDefinition = {
+  name: "bullet"
+}, defaultStrongDecoratorDefinition = {
+  name: "strong"
+}, defaultEmDecoratorDefinition = {
+  name: "em"
+}, defaultCodeDecoratorDefinition = {
+  name: "code"
+}, defaultStrikeThroughDecoratorDefinition = {
+  name: "strike-through"
+}, defaultLinkObjectDefinition = {
+  name: "link",
+  fields: [
+    { name: "href", type: "string" },
+    { name: "title", type: "string" }
+  ]
+}, defaultCodeObjectDefinition = {
+  name: "code",
+  fields: [
+    { name: "language", type: "string" },
+    { name: "code", type: "string" }
+  ]
+}, defaultImageObjectDefinition = {
+  name: "image",
+  fields: [
+    { name: "src", type: "string" },
+    { name: "alt", type: "string" },
+    { name: "title", type: "string" }
+  ]
+}, defaultHorizontalRuleObjectDefinition = {
+  name: "horizontal-rule"
+}, defaultHtmlObjectDefinition = {
+  name: "html",
+  fields: [{ name: "html", type: "string" }]
+}, defaultTableObjectDefinition = {
+  name: "table",
+  fields: [
+    { name: "headerRows", type: "number" },
+    { name: "rows", type: "array" }
+  ]
+}, defaultSchema = compileSchema(
+  defineSchema({
+    styles: [
+      normalStyleDefinition,
+      h1StyleDefinition,
+      h2StyleDefinition,
+      h3StyleDefinition,
+      h4StyleDefinition,
+      h5StyleDefinition,
+      h6StyleDefinition,
+      blockquoteStyleDefinition
+    ],
+    lists: [
+      defaultOrderedListItemDefinition,
+      defaultUnorderedListItemDefinition
+    ],
+    decorators: [
+      defaultStrongDecoratorDefinition,
+      defaultEmDecoratorDefinition,
+      defaultCodeDecoratorDefinition,
+      defaultStrikeThroughDecoratorDefinition
+    ],
+    annotations: [defaultLinkObjectDefinition],
+    blockObjects: [
+      defaultCodeObjectDefinition,
+      defaultHorizontalRuleObjectDefinition,
+      defaultImageObjectDefinition,
+      defaultHtmlObjectDefinition,
+      defaultTableObjectDefinition
+    ],
+    inlineObjects: [defaultImageObjectDefinition]
+  })
+);
+function buildStyleMatcher(definition) {
+  return ({ context }) => {
+    const schemaDefinition = context.schema.styles.find(
+      (item) => item.name === definition.name
+    );
+    if (schemaDefinition)
+      return schemaDefinition.name;
+  };
+}
+function buildListItemMatcher(definition) {
+  return ({ context }) => {
+    const schemaDefinition = context.schema.lists.find(
+      (item) => item.name === definition.name
+    );
+    if (schemaDefinition)
+      return schemaDefinition.name;
+  };
+}
+function buildDecoratorMatcher(definition) {
+  return ({ context }) => {
+    const schemaDefinition = context.schema.decorators.find(
+      (item) => item.name === definition.name
+    );
+    if (schemaDefinition)
+      return schemaDefinition.name;
+  };
+}
+function buildAnnotationMatcher(definition) {
+  return ({ context, value }) => {
+    const schemaDefinition = context.schema.annotations.find(
+      (item) => item.name === definition.name
+    );
+    if (!schemaDefinition)
+      return;
+    const filteredValue = schemaDefinition.fields.reduce((filteredValue2, field) => {
+      const fieldValue = value[field.name];
+      return fieldValue !== void 0 && (filteredValue2[field.name] = fieldValue), filteredValue2;
+    }, {});
+    return {
+      _key: context.keyGenerator(),
+      _type: schemaDefinition.name,
+      ...filteredValue
+    };
+  };
+}
+function buildObjectMatcher(definition) {
+  return ({ context, value, isInline }) => {
+    const schemaDefinition = (isInline ? context.schema.inlineObjects : context.schema.blockObjects).find(
+      (item) => item.name === definition.name
+    );
+    if (!schemaDefinition)
+      return;
+    const filteredValue = schemaDefinition.fields.reduce((filteredValue2, field) => {
+      const fieldValue = value[field.name];
+      return fieldValue !== void 0 && (filteredValue2[field.name] = fieldValue), filteredValue2;
+    }, {});
+    return {
+      _key: context.keyGenerator(),
+      _type: schemaDefinition.name,
+      ...filteredValue
+    };
+  };
+}
+const codeBlockMatcher = ({ context, value, isInline }) => {
+  const codeObject = buildObjectMatcher(defaultCodeObjectDefinition)({ context, value, isInline });
+  if (codeObject && "code" in codeObject)
+    return codeObject;
+}, imageBlockMatcher = ({ context, value, isInline }) => {
+  const imageObject = buildObjectMatcher(defaultImageObjectDefinition)({ context, value, isInline });
+  if (imageObject && "src" in imageObject)
+    return imageObject;
+}, defaultOptions = {
+  block: {
+    normal: buildStyleMatcher(normalStyleDefinition),
+    blockquote: buildStyleMatcher(blockquoteStyleDefinition),
+    h1: buildStyleMatcher(h1StyleDefinition),
+    h2: buildStyleMatcher(h2StyleDefinition),
+    h3: buildStyleMatcher(h3StyleDefinition),
+    h4: buildStyleMatcher(h4StyleDefinition),
+    h5: buildStyleMatcher(h5StyleDefinition),
+    h6: buildStyleMatcher(h6StyleDefinition)
+  },
+  listItem: {
+    number: buildListItemMatcher(defaultOrderedListItemDefinition),
+    bullet: buildListItemMatcher(defaultUnorderedListItemDefinition)
+  },
+  marks: {
+    strong: buildDecoratorMatcher(defaultStrongDecoratorDefinition),
+    em: buildDecoratorMatcher(defaultEmDecoratorDefinition),
+    code: buildDecoratorMatcher(defaultCodeDecoratorDefinition),
+    strikeThrough: buildDecoratorMatcher(
+      defaultStrikeThroughDecoratorDefinition
+    ),
+    link: buildAnnotationMatcher(defaultLinkObjectDefinition)
+  },
+  types: {
+    code: codeBlockMatcher,
+    horizontalRule: buildObjectMatcher(defaultHorizontalRuleObjectDefinition),
+    html: buildObjectMatcher(defaultHtmlObjectDefinition),
+    image: imageBlockMatcher
+  }
+};
+function flattenTable(table, portableText) {
+  for (const row of table.rows)
+    for (const cell of row.cells)
+      for (const block of cell.value)
+        portableText.push(block);
+}
+function markdownToPortableText(markdown, options) {
+  const consolidatedOptions = {
+    schema: options?.schema ?? defaultSchema,
+    keyGenerator: options?.keyGenerator ?? defaultKeyGenerator,
+    html: {
+      inline: options?.html?.inline ?? "skip"
+    },
+    marks: {
+      ...defaultOptions.marks,
+      ...options?.marks
+    },
+    block: {
+      ...defaultOptions.block,
+      ...options?.block
+    },
+    listItem: {
+      ...defaultOptions.listItem,
+      ...options?.listItem
+    },
+    types: {
+      ...defaultOptions.types,
+      ...options?.types
+    }
+  }, tokens = markdownit({
+    html: !0,
+    linkify: !0,
+    typographer: !1
+  }).enable(["strikethrough", "table"]).parse(markdown, {}), portableText = [];
+  let currentBlock = null;
+  const currentListStack = [], markDefRefs = [];
+  let currentMarkDefs = [], currentBlockquoteStyle = null, inListItem = !1, currentTable = null, currentTableRow = null, inTableHead = !1;
+  const startBlock = (style) => {
+    flushBlock(), currentBlock = {
+      _type: "block",
+      style,
+      children: [],
+      _key: consolidatedOptions.keyGenerator(),
+      markDefs: []
+    }, currentMarkDefs = [];
+  }, flushBlock = () => {
+    currentBlock && (currentBlock.children.length === 0 && currentBlock.children.push({
+      _type: consolidatedOptions.schema.span.name,
+      _key: consolidatedOptions.keyGenerator(),
+      text: "",
+      marks: []
+    }), currentBlock.markDefs = currentMarkDefs, portableText.push(currentBlock), currentBlock = null, currentMarkDefs = []);
+  }, addSpan = (text) => {
+    if (text.length === 0)
+      return;
+    if (!currentBlock)
+      throw new Error("Expected current block");
+    const lastChild = currentBlock.children.at(-1);
+    isSpan({ schema: consolidatedOptions.schema }, lastChild) && lastChild.marks?.every((mark) => markDefRefs.includes(mark)) && markDefRefs.every((mark) => lastChild.marks?.includes(mark)) ? lastChild.text += text : currentBlock.children.push({
+      _type: consolidatedOptions.schema.span.name,
+      _key: consolidatedOptions.keyGenerator(),
+      text,
+      marks: [...markDefRefs]
+    });
+  }, listLevel = () => currentListStack.length, ensureListBlock = (listItem) => {
+    if (!currentBlock) {
+      const style = currentBlockquoteStyle ?? consolidatedOptions.block.normal({
+        context: { schema: consolidatedOptions.schema }
+      });
+      style ? startBlock(style) : (console.warn('No default style found, using "normal"'), startBlock("normal"));
+    }
+    if (!currentBlock)
+      throw new Error("Expected current block");
+    (currentBlock.listItem !== listItem || currentBlock.level !== listLevel()) && (currentBlock.listItem = listItem, currentBlock.level = listLevel());
+  };
+  for (const token of tokens)
+    switch (token.type) {
+      // Paragraphs
+      case "paragraph_open": {
+        if (inListItem)
+          break;
+        const style = currentBlockquoteStyle ?? consolidatedOptions.block.normal({
+          context: { schema: consolidatedOptions.schema }
+        });
+        if (!style) {
+          console.warn('No default style found, using "normal"'), startBlock("normal");
+          break;
+        }
+        startBlock(style);
+        break;
+      }
+      case "paragraph_close":
+        if (inListItem)
+          break;
+        flushBlock();
+        break;
+      // Headings
+      case "heading_open": {
+        const level = Number(token?.tag?.slice(1)), headingMatcher = {
+          1: consolidatedOptions.block.h1,
+          2: consolidatedOptions.block.h2,
+          3: consolidatedOptions.block.h3,
+          4: consolidatedOptions.block.h4,
+          5: consolidatedOptions.block.h5,
+          6: consolidatedOptions.block.h6
+        }[level], style = headingMatcher?.({
+          context: { schema: consolidatedOptions.schema }
+        }) ?? consolidatedOptions.block.normal({
+          context: { schema: consolidatedOptions.schema }
+        });
+        if (!style) {
+          console.warn('No heading style found, using "normal"'), startBlock("normal");
+          break;
+        }
+        startBlock(style);
+        break;
+      }
+      case "heading_close":
+        flushBlock();
+        break;
+      // Blockquote
+      case "blockquote_open": {
+        currentBlockquoteStyle = consolidatedOptions.block.blockquote({
+          context: { schema: consolidatedOptions.schema }
+        }) ?? consolidatedOptions.block.normal({
+          context: { schema: consolidatedOptions.schema }
+        }) ?? "normal";
+        break;
+      }
+      case "blockquote_close": {
+        currentBlockquoteStyle = null;
+        break;
+      }
+      // Lists
+      case "bullet_list_open": {
+        const listItem = consolidatedOptions.listItem.bullet({
+          context: { schema: consolidatedOptions.schema }
+        });
+        if (!listItem) {
+          currentListStack.push(null);
+          break;
+        }
+        currentListStack.push(listItem);
+        break;
+      }
+      case "ordered_list_open": {
+        const listItem = consolidatedOptions.listItem.number({
+          context: { schema: consolidatedOptions.schema }
+        });
+        if (!listItem) {
+          currentListStack.push(null);
+          break;
+        }
+        currentListStack.push(listItem);
+        break;
+      }
+      case "bullet_list_close":
+      case "ordered_list_close":
+        currentListStack.pop();
+        break;
+      case "list_item_open": {
+        const listType = currentListStack.at(-1);
+        if (listType === void 0)
+          throw new Error("Expected an open list");
+        if (currentBlock && flushBlock(), listType === null) {
+          const style = currentBlockquoteStyle ?? consolidatedOptions.block.normal({
+            context: { schema: consolidatedOptions.schema }
+          });
+          style ? startBlock(style) : (console.warn('No default style found, using "normal"'), startBlock("normal")), inListItem = !0;
+          break;
+        }
+        ensureListBlock(listType), inListItem = !0;
+        break;
+      }
+      case "list_item_close":
+        inListItem = !1, flushBlock();
+        break;
+      // Code fences / blocks
+      case "fence": {
+        flushBlock();
+        const language = token.info.trim() || void 0, code = token.content.replace(/\n$/, ""), codeObject = consolidatedOptions.types.code({
+          context: {
+            schema: consolidatedOptions.schema,
+            keyGenerator: consolidatedOptions.keyGenerator
+          },
+          value: { language, code },
+          isInline: !1
+        });
+        if (!codeObject) {
+          if (code.includes(`
+`))
+            portableText.push({
+              _type: "code",
+              _key: consolidatedOptions.keyGenerator(),
+              code
+            });
+          else {
+            const style = consolidatedOptions.block.normal({
+              context: { schema: consolidatedOptions.schema }
+            });
+            style ? startBlock(style) : (console.warn('No default style found, using "normal"'), startBlock("normal")), addSpan(code);
+          }
+          break;
+        }
+        portableText.push(codeObject);
+        break;
+      }
+      // Horizontal rule
+      case "hr": {
+        flushBlock();
+        const hrObject = consolidatedOptions.types.horizontalRule({
+          context: {
+            schema: consolidatedOptions.schema,
+            keyGenerator: consolidatedOptions.keyGenerator
+          },
+          value: {},
+          isInline: !1
+        });
+        if (!hrObject) {
+          const style = consolidatedOptions.block.normal({
+            context: { schema: consolidatedOptions.schema }
+          });
+          style ? startBlock(style) : (console.warn('No default style found, using "normal"'), startBlock("normal")), addSpan("---"), flushBlock();
+          break;
+        }
+        portableText.push(hrObject);
+        break;
+      }
+      // HTML block
+      case "html_block": {
+        flushBlock();
+        const htmlContent = token.content.trim();
+        if (!htmlContent)
+          break;
+        const htmlObject = consolidatedOptions.types.html({
+          context: {
+            schema: consolidatedOptions.schema,
+            keyGenerator: consolidatedOptions.keyGenerator
+          },
+          value: { html: htmlContent },
+          isInline: !1
+        });
+        if (!htmlObject) {
+          const style = consolidatedOptions.block.normal({
+            context: { schema: consolidatedOptions.schema }
+          });
+          style ? startBlock(style) : (console.warn('No default style found, using "normal"'), startBlock("normal")), addSpan(htmlContent), flushBlock();
+          break;
+        }
+        portableText.push(htmlObject);
+        break;
+      }
+      case "code_block": {
+        flushBlock();
+        const code = token.content.replace(/\n$/, ""), codeObject = consolidatedOptions.types.code({
+          context: {
+            schema: consolidatedOptions.schema,
+            keyGenerator: consolidatedOptions.keyGenerator
+          },
+          value: { language: void 0, code },
+          isInline: !1
+        });
+        if (codeObject)
+          portableText.push(codeObject);
+        else if (code.includes(`
+`))
+          portableText.push({
+            _type: "code",
+            _key: consolidatedOptions.keyGenerator(),
+            code
+          });
+        else {
+          const style = consolidatedOptions.block.normal({
+            context: { schema: consolidatedOptions.schema }
+          });
+          style ? startBlock(style) : (console.warn('No default style found, using "normal"'), startBlock("normal")), addSpan(code);
+        }
+        break;
+      }
+      // Tables
+      case "table_open":
+        flushBlock(), currentTable = { rows: [], headerRows: 0 };
+        break;
+      case "table_close": {
+        if (!currentTable)
+          break;
+        if (consolidatedOptions.types.table) {
+          const tableObject = consolidatedOptions.types.table({
+            context: {
+              schema: consolidatedOptions.schema,
+              keyGenerator: consolidatedOptions.keyGenerator
+            },
+            value: {
+              rows: currentTable.rows,
+              headerRows: currentTable.headerRows > 0 ? currentTable.headerRows : void 0
+            },
+            isInline: !1
+          });
+          tableObject ? portableText.push(tableObject) : flattenTable(currentTable, portableText);
+        } else
+          flattenTable(currentTable, portableText);
+        currentTable = null;
+        break;
+      }
+      case "thead_open":
+        inTableHead = !0;
+        break;
+      case "thead_close":
+        inTableHead = !1;
+        break;
+      case "tbody_open":
+      case "tbody_close":
+        break;
+      case "tr_open":
+        currentTableRow = [];
+        break;
+      case "tr_close":
+        currentTable && currentTableRow && (currentTable.rows.push({
+          _key: consolidatedOptions.keyGenerator(),
+          _type: "row",
+          cells: currentTableRow
+        }), inTableHead && currentTable.headerRows++), currentTableRow = null;
+        break;
+      case "th_open":
+      case "td_open": {
+        const style = consolidatedOptions.block.normal({
+          context: { schema: consolidatedOptions.schema }
+        });
+        style ? startBlock(style) : (console.warn('No default style found, using "normal"'), startBlock("normal"));
+        break;
+      }
+      case "th_close":
+      case "td_close": {
+        flushBlock();
+        const cellBlocks = [];
+        if (portableText.length > 0) {
+          const lastBlock = portableText.at(-1);
+          lastBlock && lastBlock._type === "block" && cellBlocks.push(portableText.pop());
+        }
+        cellBlocks.length === 0 && cellBlocks.push({
+          _type: "block",
+          style: consolidatedOptions.block.normal({
+            context: { schema: consolidatedOptions.schema }
+          }) || "normal",
+          children: [
+            {
+              _type: consolidatedOptions.schema.span.name,
+              _key: consolidatedOptions.keyGenerator(),
+              text: "",
+              marks: []
+            }
+          ],
+          _key: consolidatedOptions.keyGenerator(),
+          markDefs: []
+        });
+        const firstBlock = cellBlocks[0];
+        if (cellBlocks.length === 1 && firstBlock && firstBlock._type === "block" && "children" in firstBlock && Array.isArray(firstBlock.children) && firstBlock.children.length === 1) {
+          const onlyChild = firstBlock.children[0];
+          typeof onlyChild == "object" && onlyChild !== null && "_type" in onlyChild && onlyChild._type !== consolidatedOptions.schema.span.name && onlyChild._type === "image" && (cellBlocks[0] = onlyChild);
+        }
+        currentTableRow !== null && currentTableRow.push({
+          _type: "cell",
+          _key: consolidatedOptions.keyGenerator(),
+          value: cellBlocks
+        });
+        break;
+      }
+      // Inline container
+      case "inline": {
+        const inTableCell = currentTableRow !== null;
+        if (token.children?.length === 1 && token.children[0]?.type === "image") {
+          const imageToken = token.children[0];
+          if (!imageToken)
+            break;
+          const src = imageToken.attrs?.find(([name]) => name === "src")?.at(1) || "", alt = imageToken.content || "", title = imageToken.attrs?.find(([name]) => name === "title")?.at(1) || void 0, blockImageObject = consolidatedOptions.types.image({
+            context: {
+              schema: consolidatedOptions.schema,
+              keyGenerator: consolidatedOptions.keyGenerator
+            },
+            value: { src, alt, title },
+            isInline: !1
+          });
+          if (blockImageObject) {
+            inTableCell ? currentBlock && "children" in currentBlock && currentBlock.children.push(
+              blockImageObject
+            ) : (currentBlock = null, currentMarkDefs = [], portableText.push(blockImageObject));
+            break;
+          }
+          addSpan(`![${alt}](${src})`);
+          break;
+        }
+        for (const childToken of token.children ?? [])
+          switch (childToken.type) {
+            case "text":
+              addSpan(childToken.content);
+              break;
+            case "softbreak":
+            case "hardbreak":
+              addSpan(`
+`);
+              break;
+            case "code_inline": {
+              const decorator = consolidatedOptions.marks.code({
+                context: { schema: consolidatedOptions.schema }
+              });
+              if (!decorator) {
+                addSpan(childToken.content);
+                break;
+              }
+              markDefRefs.push(decorator), addSpan(childToken.content);
+              const index = markDefRefs.lastIndexOf(decorator);
+              index !== -1 && markDefRefs.splice(index, 1);
+              break;
+            }
+            case "strong_open": {
+              const decorator = consolidatedOptions.marks.strong({
+                context: { schema: consolidatedOptions.schema }
+              });
+              if (!decorator)
+                break;
+              markDefRefs.push(decorator);
+              break;
+            }
+            case "strong_close": {
+              const decorator = consolidatedOptions.marks.strong({
+                context: { schema: consolidatedOptions.schema }
+              });
+              if (!decorator)
+                break;
+              const index = markDefRefs.lastIndexOf(decorator);
+              index !== -1 && markDefRefs.splice(index, 1);
+              break;
+            }
+            case "em_open": {
+              const decorator = consolidatedOptions.marks.em({
+                context: { schema: consolidatedOptions.schema }
+              });
+              if (!decorator)
+                break;
+              markDefRefs.push(decorator);
+              break;
+            }
+            case "em_close": {
+              const decorator = consolidatedOptions.marks.em({
+                context: { schema: consolidatedOptions.schema }
+              });
+              if (!decorator)
+                break;
+              const index = markDefRefs.lastIndexOf(decorator);
+              index !== -1 && markDefRefs.splice(index, 1);
+              break;
+            }
+            case "s_open": {
+              const decorator = consolidatedOptions.marks.strikeThrough({
+                context: { schema: consolidatedOptions.schema }
+              });
+              if (!decorator)
+                break;
+              markDefRefs.push(decorator);
+              break;
+            }
+            case "s_close": {
+              const decorator = consolidatedOptions.marks.strikeThrough({
+                context: { schema: consolidatedOptions.schema }
+              });
+              if (!decorator)
+                break;
+              const index = markDefRefs.lastIndexOf(decorator);
+              index !== -1 && markDefRefs.splice(index, 1);
+              break;
+            }
+            case "link_open": {
+              const href = childToken.attrs?.find(([name]) => name === "href")?.at(1);
+              if (!href)
+                break;
+              const title = childToken.attrs?.find(([name]) => name === "title")?.at(1), linkObject = consolidatedOptions.marks.link({
+                context: {
+                  schema: consolidatedOptions.schema,
+                  keyGenerator: consolidatedOptions.keyGenerator
+                },
+                value: { href, title }
+              });
+              if (!linkObject)
+                break;
+              currentMarkDefs.push(linkObject), markDefRefs.push(linkObject._key);
+              break;
+            }
+            case "link_close": {
+              const markDefKeys = new Set(currentMarkDefs.map((d) => d._key));
+              let lastLinkIndex;
+              for (const markDefRef of markDefRefs.reverse())
+                if (markDefKeys.has(markDefRef)) {
+                  lastLinkIndex = markDefRefs.indexOf(markDefRef);
+                  break;
+                }
+              if (lastLinkIndex !== void 0) {
+                const realIndex = markDefRefs.length - 1 - lastLinkIndex;
+                markDefRefs.splice(realIndex, 1);
+              }
+              break;
+            }
+            case "image": {
+              const src = childToken.attrs?.find(([name]) => name === "src")?.at(1) || "", alt = childToken.content || "", inlineImageObject = consolidatedOptions.types.image({
+                context: {
+                  schema: consolidatedOptions.schema,
+                  keyGenerator: consolidatedOptions.keyGenerator
+                },
+                value: { src, alt, title: void 0 },
+                isInline: !0
+              });
+              if (inlineImageObject) {
+                if (!currentBlock) {
+                  const style2 = consolidatedOptions.block.normal({
+                    context: { schema: consolidatedOptions.schema }
+                  });
+                  style2 ? startBlock(style2) : (console.warn('No default style found, using "normal"'), startBlock("normal"));
+                }
+                if (!currentBlock)
+                  throw new Error("Expected current block after startBlock");
+                currentBlock.children.push(
+                  inlineImageObject
+                );
+                break;
+              }
+              const blockImageObject = consolidatedOptions.types.image({
+                context: {
+                  schema: consolidatedOptions.schema,
+                  keyGenerator: consolidatedOptions.keyGenerator
+                },
+                value: { src, alt, title: void 0 },
+                isInline: !1
+              });
+              if (!blockImageObject) {
+                addSpan(`![${alt}](${src})`);
+                break;
+              }
+              if (inTableCell) {
+                currentBlock && "children" in currentBlock && currentBlock.children.push(
+                  blockImageObject
+                );
+                break;
+              }
+              flushBlock(), portableText.push(blockImageObject);
+              const style = consolidatedOptions.block.normal({
+                context: { schema: consolidatedOptions.schema }
+              });
+              style && startBlock(style);
+              break;
+            }
+            case "html_inline": {
+              consolidatedOptions.html.inline === "text" && addSpan(childToken.content);
+              break;
+            }
+          }
+        break;
+      }
+    }
+  return flushBlock(), portableText;
+}
+export {
+  DefaultBlockSpacingRenderer,
+  DefaultBlockquoteRenderer,
+  DefaultCodeBlockRenderer,
+  DefaultCodeRenderer,
+  DefaultEmRenderer,
+  DefaultH1Renderer,
+  DefaultH2Renderer,
+  DefaultH3Renderer,
+  DefaultH4Renderer,
+  DefaultH5Renderer,
+  DefaultH6Renderer,
+  DefaultHardBreakRenderer,
+  DefaultHorizontalRuleRenderer,
+  DefaultHtmlRenderer,
+  DefaultImageRenderer,
+  DefaultLinkRenderer,
+  DefaultListItemRenderer,
+  DefaultNormalRenderer,
+  DefaultStrikeThroughRenderer,
+  DefaultStrongRenderer,
+  DefaultTableRenderer,
+  DefaultUnderlineRenderer,
+  markdownToPortableText,
+  portableTextToMarkdown
+};
+//# sourceMappingURL=index.js.map