@mjhls/mjh-framework 1.0.1005-next12-0003 → 1.0.1005-sap-context-test-v2

package/dist/esm/BlockContent-1e73bd2c.js

@@ -0,0 +1,909 @@
+import React__default from 'react';
+import PropTypes from 'prop-types';
+import { n as node } from './index-3f5c03b2.js';
+
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+/* eslint-disable no-unused-vars */
+var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+function toObject(val) {
+	if (val === null || val === undefined) {
+		throw new TypeError('Object.assign cannot be called with null or undefined');
+	}
+
+	return Object(val);
+}
+
+function shouldUseNative() {
+	try {
+		if (!Object.assign) {
+			return false;
+		}
+
+		// Detect buggy property enumeration order in older V8 versions.
+
+		// https://bugs.chromium.org/p/v8/issues/detail?id=4118
+		var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
+		test1[5] = 'de';
+		if (Object.getOwnPropertyNames(test1)[0] === '5') {
+			return false;
+		}
+
+		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+		var test2 = {};
+		for (var i = 0; i < 10; i++) {
+			test2['_' + String.fromCharCode(i)] = i;
+		}
+		var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+			return test2[n];
+		});
+		if (order2.join('') !== '0123456789') {
+			return false;
+		}
+
+		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+		var test3 = {};
+		'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+			test3[letter] = letter;
+		});
+		if (Object.keys(Object.assign({}, test3)).join('') !==
+				'abcdefghijklmnopqrst') {
+			return false;
+		}
+
+		return true;
+	} catch (err) {
+		// We don't expect any of the above to throw, but better to be safe.
+		return false;
+	}
+}
+
+var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
+	var from;
+	var to = toObject(target);
+	var symbols;
+
+	for (var s = 1; s < arguments.length; s++) {
+		from = Object(arguments[s]);
+
+		for (var key in from) {
+			if (hasOwnProperty.call(from, key)) {
+				to[key] = from[key];
+			}
+		}
+
+		if (getOwnPropertySymbols) {
+			symbols = getOwnPropertySymbols(from);
+			for (var i = 0; i < symbols.length; i++) {
+				if (propIsEnumerable.call(from, symbols[i])) {
+					to[symbols[i]] = from[symbols[i]];
+				}
+			}
+		}
+	}
+
+	return to;
+};
+
+var baseUrl = 'https://docs.sanity.io/help/';
+
+var generateHelpUrl = function generateHelpUrl(slug) {
+  return baseUrl + slug
+};
+
+var enc = encodeURIComponent;
+var materializeError = "You must either:\n  - Pass `projectId` and `dataset` to the block renderer\n  - Materialize images to include the `url` field.\n\nFor more information, see ".concat(generateHelpUrl('block-content-image-materializing'));
+
+var getQueryString = function getQueryString(options) {
+  var query = options.imageOptions;
+  var keys = Object.keys(query);
+
+  if (!keys.length) {
+    return '';
+  }
+
+  var params = keys.map(function (key) {
+    return "".concat(enc(key), "=").concat(enc(query[key]));
+  });
+  return "?".concat(params.join('&'));
+};
+
+var buildUrl = function buildUrl(props) {
+  var node$1 = props.node,
+      options = props.options;
+  var projectId = options.projectId,
+      dataset = options.dataset;
+  var asset = node$1.asset;
+
+  if (!asset) {
+    throw new Error('Image does not have required `asset` property');
+  }
+
+  if (asset.url) {
+    return asset.url + getQueryString(options);
+  }
+
+  if (!projectId || !dataset) {
+    throw new Error(materializeError);
+  }
+
+  var ref = asset._ref;
+
+  if (!ref) {
+    throw new Error('Invalid image reference in block, no `_ref` found on `asset`');
+  }
+
+  return node(objectAssign({
+    projectId: projectId,
+    dataset: dataset
+  }, options.imageOptions || {})).image(node$1).toString();
+};
+
+var getImageUrl$1 = buildUrl;
+
+var serializers$1 = function (h, serializerOpts) {
+  var serializeOptions = serializerOpts || {
+    useDashedStyles: false // Low-level block serializer
+
+  };
+
+  function BlockSerializer(props) {
+    var node = props.node,
+        serializers = props.serializers,
+        options = props.options,
+        isInline = props.isInline,
+        children = props.children;
+    var blockType = node._type;
+    var serializer = serializers.types[blockType];
+
+    if (!serializer) {
+      throw new Error("Unknown block type \"".concat(blockType, "\", please specify a serializer for it in the `serializers.types` prop"));
+    }
+
+    return h(serializer, {
+      node: node,
+      options: options,
+      isInline: isInline
+    }, children);
+  } // Low-level span serializer
+
+
+  function SpanSerializer(props) {
+    var _props$node = props.node,
+        mark = _props$node.mark,
+        children = _props$node.children;
+    var isPlain = typeof mark === 'string';
+    var markType = isPlain ? mark : mark._type;
+    var serializer = props.serializers.marks[markType];
+
+    if (!serializer) {
+      // @todo Revert back to throwing errors?
+      // eslint-disable-next-line no-console
+      console.warn("Unknown mark type \"".concat(markType, "\", please specify a serializer for it in the `serializers.marks` prop"));
+      return h(props.serializers.markFallback, null, children);
+    }
+
+    return h(serializer, props.node, children);
+  } // Low-level list serializer
+
+
+  function ListSerializer(props) {
+    var tag = props.type === 'bullet' ? 'ul' : 'ol';
+    return h(tag, null, props.children);
+  } // Low-level list item serializer
+
+
+  function ListItemSerializer(props) {
+    var children = !props.node.style || props.node.style === 'normal' ? // Don't wrap plain text in paragraphs inside of a list item
+    props.children : // But wrap any other style in whatever the block serializer says to use
+    h(props.serializers.types.block, props, props.children);
+    return h('li', null, children);
+  } // Renderer of an actual block of type `block`. Confusing, we know.
+
+
+  function BlockTypeSerializer(props) {
+    var style = props.node.style || 'normal';
+
+    if (/^h\d/.test(style)) {
+      return h(style, null, props.children);
+    }
+
+    return style === 'blockquote' ? h('blockquote', null, props.children) : h('p', null, props.children);
+  } // Serializers for things that can be directly attributed to a tag without any props
+  // We use partial application to do this, passing the tag name as the first argument
+
+
+  function RawMarkSerializer(tag, props) {
+    return h(tag, null, props.children);
+  }
+
+  function UnderlineSerializer(props) {
+    var style = serializeOptions.useDashedStyles ? {
+      'text-decoration': 'underline'
+    } : {
+      textDecoration: 'underline'
+    };
+    return h('span', {
+      style: style
+    }, props.children);
+  }
+
+  function StrikeThroughSerializer(props) {
+    return h('del', null, props.children);
+  }
+
+  function LinkSerializer(props) {
+    return h('a', {
+      href: props.mark.href
+    }, props.children);
+  }
+
+  function ImageSerializer(props) {
+    if (!props.node.asset) {
+      return null;
+    }
+
+    var img = h('img', {
+      src: getImageUrl$1(props)
+    });
+    return props.isInline ? img : h('figure', null, img);
+  } // Serializer that recursively calls itself, producing a hyperscript tree of spans
+
+
+  function serializeSpan(span, serializers, index, options) {
+    if (span === '\n' && serializers.hardBreak) {
+      return h(serializers.hardBreak, {
+        key: "hb-".concat(index)
+      });
+    }
+
+    if (typeof span === 'string') {
+      return serializers.text ? h(serializers.text, {
+        key: "text-".concat(index)
+      }, span) : span;
+    }
+
+    var children;
+
+    if (span.children) {
+      children = {
+        children: span.children.map(function (child, i) {
+          return options.serializeNode(child, i, span.children, true);
+        })
+      };
+    }
+
+    var serializedNode = objectAssign({}, span, children);
+    return h(serializers.span, {
+      key: span._key || "span-".concat(index),
+      node: serializedNode,
+      serializers: serializers
+    });
+  }
+
+  var HardBreakSerializer = function HardBreakSerializer() {
+    return h('br');
+  };
+
+  var defaultMarkSerializers = {
+    strong: RawMarkSerializer.bind(null, 'strong'),
+    em: RawMarkSerializer.bind(null, 'em'),
+    code: RawMarkSerializer.bind(null, 'code'),
+    underline: UnderlineSerializer,
+    'strike-through': StrikeThroughSerializer,
+    link: LinkSerializer
+  };
+  var defaultSerializers = {
+    // Common overrides
+    types: {
+      block: BlockTypeSerializer,
+      image: ImageSerializer
+    },
+    marks: defaultMarkSerializers,
+    // Less common overrides
+    list: ListSerializer,
+    listItem: ListItemSerializer,
+    block: BlockSerializer,
+    span: SpanSerializer,
+    hardBreak: HardBreakSerializer,
+    // Container element
+    container: 'div',
+    // When we can't resolve the mark properly, use this renderer as the container
+    markFallback: 'span',
+    // Allow overriding text renderer, but leave undefined to just use plain strings by default
+    text: undefined,
+    // Empty nodes (React uses null, hyperscript with empty strings)
+    empty: ''
+  };
+  return {
+    defaultSerializers: defaultSerializers,
+    serializeSpan: serializeSpan
+  };
+};
+
+var defaultMarks = ['strong', 'em', 'code', 'underline', 'strike-through'];
+
+var buildMarksTree = function buildMarksTree(block) {
+  var children = block.children,
+      markDefs = block.markDefs;
+
+  if (!children || !children.length) {
+    return [];
+  }
+
+  var sortedMarks = children.map(sortMarksByOccurences);
+  var rootNode = {
+    _type: 'span',
+    children: []
+  };
+  var nodeStack = [rootNode];
+  children.forEach(function (span, i) {
+    var marksNeeded = sortedMarks[i];
+
+    if (!marksNeeded) {
+      var lastNode = nodeStack[nodeStack.length - 1];
+      lastNode.children.push(span);
+      return;
+    }
+
+    var pos = 1; // Start at position one. Root is always plain and should never be removed. (?)
+
+    if (nodeStack.length > 1) {
+      for (pos; pos < nodeStack.length; pos++) {
+        var mark = nodeStack[pos].markKey;
+        var index = marksNeeded.indexOf(mark); // eslint-disable-next-line max-depth
+
+        if (index === -1) {
+          break;
+        }
+
+        marksNeeded.splice(index, 1);
+      }
+    } // Keep from beginning to first miss
+
+
+    nodeStack = nodeStack.slice(0, pos); // Add needed nodes
+
+    var currentNode = findLastParentNode(nodeStack);
+    marksNeeded.forEach(function (mark) {
+      var node = {
+        _type: 'span',
+        _key: span._key,
+        children: [],
+        mark: markDefs.find(function (def) {
+          return def._key === mark;
+        }) || mark,
+        markKey: mark
+      };
+      currentNode.children.push(node);
+      nodeStack.push(node);
+      currentNode = node;
+    }); // Split at newlines to make individual line chunks, but keep newline
+    // characters as individual elements in the array. We use these characters
+    // in the span serializer to trigger hard-break rendering
+
+    if (isTextSpan(span)) {
+      var lines = span.text.split('\n');
+
+      for (var line = lines.length; line-- > 1;) {
+        lines.splice(line, 0, '\n');
+      }
+
+      currentNode.children = currentNode.children.concat(lines);
+    } else {
+      currentNode.children = currentNode.children.concat(span);
+    }
+  });
+  return rootNode.children;
+}; // We want to sort all the marks of all the spans in the following order:
+// 1. Marks that are shared amongst the most adjacent siblings
+// 2. Non-default marks (links, custom metadata)
+// 3. Built-in, plain marks (bold, emphasis, code etc)
+
+
+function sortMarksByOccurences(span, i, spans) {
+  if (!span.marks || span.marks.length === 0) {
+    return span.marks || [];
+  }
+
+  var markOccurences = span.marks.reduce(function (occurences, mark) {
+    occurences[mark] = occurences[mark] ? occurences[mark] + 1 : 1;
+
+    for (var siblingIndex = i + 1; siblingIndex < spans.length; siblingIndex++) {
+      var sibling = spans[siblingIndex];
+
+      if (sibling.marks && Array.isArray(sibling.marks) && sibling.marks.indexOf(mark) !== -1) {
+        occurences[mark]++;
+      } else {
+        break;
+      }
+    }
+
+    return occurences;
+  }, {});
+  var sortByOccurence = sortMarks.bind(null, markOccurences); // Slicing because sort() mutates the input
+
+  return span.marks.slice().sort(sortByOccurence);
+}
+
+function sortMarks(occurences, markA, markB) {
+  var aOccurences = occurences[markA] || 0;
+  var bOccurences = occurences[markB] || 0;
+
+  if (aOccurences !== bOccurences) {
+    return bOccurences - aOccurences;
+  }
+
+  var aDefaultPos = defaultMarks.indexOf(markA);
+  var bDefaultPos = defaultMarks.indexOf(markB); // Sort default marks last
+
+  if (aDefaultPos !== bDefaultPos) {
+    return aDefaultPos - bDefaultPos;
+  } // Sort other marks simply by key
+
+
+  if (markA < markB) {
+    return -1;
+  } else if (markA > markB) {
+    return 1;
+  }
+
+  return 0;
+}
+
+function isTextSpan(node) {
+  return node._type === 'span' && typeof node.text === 'string' && (Array.isArray(node.marks) || typeof node.marks === 'undefined');
+}
+
+function findLastParentNode(nodes) {
+  for (var i = nodes.length - 1; i >= 0; i--) {
+    var node = nodes[i];
+
+    if (node._type === 'span' && node.children) {
+      return node;
+    }
+  }
+
+  return undefined;
+}
+
+var buildMarksTree_1 = buildMarksTree;
+
+/* eslint-disable max-depth, complexity */
+
+
+function nestLists(blocks) {
+  var mode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'html';
+  var tree = [];
+  var currentList;
+
+  for (var i = 0; i < blocks.length; i++) {
+    var block = blocks[i];
+
+    if (!isListBlock(block)) {
+      tree.push(block);
+      currentList = null;
+      continue;
+    } // Start of a new list?
+
+
+    if (!currentList) {
+      currentList = listFromBlock(block);
+      tree.push(currentList);
+      continue;
+    } // New list item within same list?
+
+
+    if (blockMatchesList(block, currentList)) {
+      currentList.children.push(block);
+      continue;
+    } // Different list props, are we going deeper?
+
+
+    if (block.level > currentList.level) {
+      var newList = listFromBlock(block);
+
+      if (mode === 'html') {
+        // Because HTML is kinda weird, nested lists needs to be nested within list items
+        // So while you would think that we could populate the parent list with a new sub-list,
+        // We actually have to target the last list element (child) of the parent.
+        // However, at this point we need to be very careful - simply pushing to the list of children
+        // will mutate the input, and we don't want to blindly clone the entire tree.
+        // Clone the last child while adding our new list as the last child of it
+        var lastListItem = lastChild(currentList);
+        var newLastChild = objectAssign({}, lastListItem, {
+          children: lastListItem.children.concat(newList)
+        }); // Swap the last child
+
+        currentList.children[currentList.children.length - 1] = newLastChild;
+      } else {
+        currentList.children.push(newList);
+      } // Set the newly created, deeper list as the current
+
+
+      currentList = newList;
+      continue;
+    } // Different list props, are we going back up the tree?
+
+
+    if (block.level < currentList.level) {
+      // Current list has ended, and we need to hook up with a parent of the same level and type
+      var match = findListMatching(tree[tree.length - 1], block);
+
+      if (match) {
+        currentList = match;
+        currentList.children.push(block);
+        continue;
+      } // Similar parent can't be found, assume new list
+
+
+      currentList = listFromBlock(block);
+      tree.push(currentList);
+      continue;
+    } // Different list props, different list style?
+
+
+    if (block.listItem !== currentList.listItem) {
+      var _match = findListMatching(tree[tree.length - 1], {
+        level: block.level
+      });
+
+      if (_match && _match.listItem === block.listItem) {
+        currentList = _match;
+        currentList.children.push(block);
+        continue;
+      } else {
+        currentList = listFromBlock(block);
+        tree.push(currentList);
+        continue;
+      }
+    } // eslint-disable-next-line no-console
+
+
+    console.warn('Unknown state encountered for block', block);
+    tree.push(block);
+  }
+
+  return tree;
+}
+
+function isListBlock(block) {
+  return Boolean(block.listItem);
+}
+
+function blockMatchesList(block, list) {
+  return block.level === list.level && block.listItem === list.listItem;
+}
+
+function listFromBlock(block) {
+  return {
+    _type: 'list',
+    _key: "".concat(block._key, "-parent"),
+    level: block.level,
+    listItem: block.listItem,
+    children: [block]
+  };
+}
+
+function lastChild(block) {
+  return block.children && block.children[block.children.length - 1];
+}
+
+function findListMatching(rootNode, matching) {
+  var filterOnType = typeof matching.listItem === 'string';
+
+  if (rootNode._type === 'list' && rootNode.level === matching.level && filterOnType && rootNode.listItem === matching.listItem) {
+    return rootNode;
+  }
+
+  var node = lastChild(rootNode);
+
+  if (!node) {
+    return false;
+  }
+
+  return findListMatching(node, matching);
+}
+
+var nestLists_1 = nestLists;
+
+var generateKeys = function (blocks) {
+  return blocks.map(function (block) {
+    if (block._key) {
+      return block;
+    }
+
+    return objectAssign({
+      _key: getStaticKey(block)
+    }, block);
+  });
+};
+
+function getStaticKey(item) {
+  return checksum(JSON.stringify(item)).toString(36).replace(/[^A-Za-z0-9]/g, '');
+}
+/* eslint-disable no-bitwise */
+
+
+function checksum(str) {
+  var hash = 0;
+  var strlen = str.length;
+
+  if (strlen === 0) {
+    return hash;
+  }
+
+  for (var i = 0; i < strlen; i++) {
+    hash = (hash << 5) - hash + str.charCodeAt(i);
+    hash &= hash; // Convert to 32bit integer
+  }
+
+  return hash;
+}
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+
+
+var isDefined$1 = function isDefined(val) {
+  return typeof val !== 'undefined';
+}; // Recursively merge/replace default serializers with user-specified serializers
+
+
+var mergeSerializers$1 = function mergeSerializers(defaultSerializers, userSerializers) {
+  return Object.keys(defaultSerializers).reduce(function (acc, key) {
+    var type = _typeof(defaultSerializers[key]);
+
+    if (type === 'function') {
+      acc[key] = isDefined$1(userSerializers[key]) ? userSerializers[key] : defaultSerializers[key];
+    } else if (type === 'object') {
+      acc[key] = objectAssign({}, defaultSerializers[key], userSerializers[key]);
+    } else {
+      acc[key] = typeof userSerializers[key] === 'undefined' ? defaultSerializers[key] : userSerializers[key];
+    }
+
+    return acc;
+  }, {});
+};
+
+// Properties to extract from props and pass to serializers as options
+
+
+var optionProps = ['projectId', 'dataset', 'imageOptions'];
+
+var isDefined = function isDefined(val) {
+  return typeof val !== 'undefined';
+};
+
+var defaults = {
+  imageOptions: {}
+};
+
+function blocksToNodes$1(h, properties, defaultSerializers, serializeSpan) {
+  var props = objectAssign({}, defaults, properties);
+  var rawBlocks = Array.isArray(props.blocks) ? props.blocks : [props.blocks];
+  var keyedBlocks = generateKeys(rawBlocks);
+  var blocks = nestLists_1(keyedBlocks, props.listNestMode);
+  var serializers = mergeSerializers$1(defaultSerializers, props.serializers || {});
+  var options = optionProps.reduce(function (opts, key) {
+    var value = props[key];
+
+    if (isDefined(value)) {
+      opts[key] = value;
+    }
+
+    return opts;
+  }, {});
+
+  function serializeNode(node, index, siblings, isInline) {
+    if (isList(node)) {
+      return serializeList(node);
+    }
+
+    if (isListItem(node)) {
+      return serializeListItem(node, findListItemIndex(node, siblings));
+    }
+
+    if (isSpan(node)) {
+      return serializeSpan(node, serializers, index, {
+        serializeNode: serializeNode
+      });
+    }
+
+    return serializeBlock(node, index, isInline);
+  }
+
+  function findListItemIndex(node, siblings) {
+    var index = 0;
+
+    for (var i = 0; i < siblings.length; i++) {
+      if (siblings[i] === node) {
+        return index;
+      }
+
+      if (!isListItem(siblings[i])) {
+        continue;
+      }
+
+      index++;
+    }
+
+    return index;
+  }
+
+  function serializeBlock(block, index, isInline) {
+    var tree = buildMarksTree_1(block);
+    var children = tree.map(function (node, i, siblings) {
+      return serializeNode(node, i, siblings, true);
+    });
+    var blockProps = {
+      key: block._key || "block-".concat(index),
+      node: block,
+      isInline: isInline,
+      serializers: serializers,
+      options: options
+    };
+    return h(serializers.block, blockProps, children);
+  }
+
+  function serializeListItem(block, index) {
+    var key = block._key;
+    var tree = buildMarksTree_1(block);
+    var children = tree.map(serializeNode);
+    return h(serializers.listItem, {
+      node: block,
+      serializers: serializers,
+      index: index,
+      key: key,
+      options: options
+    }, children);
+  }
+
+  function serializeList(list) {
+    var type = list.listItem;
+    var level = list.level;
+    var key = list._key;
+    var children = list.children.map(serializeNode);
+    return h(serializers.list, {
+      key: key,
+      level: level,
+      type: type,
+      options: options
+    }, children);
+  } // Default to false, so `undefined` will evaluate to the default here
+
+
+  var renderContainerOnSingleChild = Boolean(props.renderContainerOnSingleChild);
+  var nodes = blocks.map(serializeNode);
+
+  if (renderContainerOnSingleChild || nodes.length > 1) {
+    var containerProps = props.className ? {
+      className: props.className
+    } : {};
+    return h(serializers.container, containerProps, nodes);
+  }
+
+  if (nodes[0]) {
+    return nodes[0];
+  }
+
+  return typeof serializers.empty === 'function' ? h(serializers.empty) : serializers.empty;
+}
+
+function isList(block) {
+  return block._type === 'list' && block.listItem;
+}
+
+function isListItem(block) {
+  return block._type === 'block' && block.listItem;
+}
+
+function isSpan(block) {
+  return typeof block === 'string' || block.marks || block._type === 'span';
+}
+
+var blocksToNodes_1 = blocksToNodes$1;
+
+var internals$1 = {
+  blocksToNodes: function blocksToNodes(renderNode, props, defaultSerializers, serializeSpan) {
+    if (defaultSerializers) {
+      return blocksToNodes_1(renderNode, props, defaultSerializers, serializeSpan);
+    } // Backwards-compatibility
+
+
+    var serializers = serializers$1(renderNode);
+    return blocksToNodes_1(renderNode, props, serializers.defaultSerializers, serializers.serializeSpan);
+  },
+  getSerializers: serializers$1,
+  getImageUrl: getImageUrl$1,
+  mergeSerializers: mergeSerializers$1
+};
+
+var internals = internals$1;
+
+var getSerializers = internals.getSerializers;
+
+var renderNode$1 = React__default.createElement;
+
+var _getSerializers = getSerializers(renderNode$1),
+    defaultSerializers = _getSerializers.defaultSerializers,
+    serializeSpan$1 = _getSerializers.serializeSpan;
+
+var dom = {
+  serializeSpan: serializeSpan$1,
+  serializers: defaultSerializers,
+  renderProps: { nestMarks: true }
+};
+
+var serializers = dom.serializers,
+    serializeSpan = dom.serializeSpan,
+    renderProps = dom.renderProps;
+
+var getImageUrl = internals.getImageUrl,
+    blocksToNodes = internals.blocksToNodes,
+    mergeSerializers = internals.mergeSerializers;
+
+var renderNode = React__default.createElement;
+
+var SanityBlockContent = function SanityBlockContent(props) {
+  var customSerializers = mergeSerializers(SanityBlockContent.defaultSerializers, props.serializers);
+
+  var blockProps = Object.assign({}, renderProps, props, {
+    serializers: customSerializers,
+    blocks: props.blocks || []
+  });
+
+  return blocksToNodes(renderNode, blockProps, serializers, serializeSpan);
+};
+
+// Expose default serializers to the user
+SanityBlockContent.defaultSerializers = serializers;
+
+// Expose logic for building image URLs from an image reference/node
+SanityBlockContent.getImageUrl = getImageUrl;
+
+SanityBlockContent.propTypes = {
+  className: PropTypes.string,
+  renderContainerOnSingleChild: PropTypes.bool,
+
+  // When rendering images, we need project id and dataset, unless images are materialized
+  projectId: PropTypes.string,
+  dataset: PropTypes.string,
+  imageOptions: PropTypes.object,
+
+  serializers: PropTypes.shape({
+    // Common overrides
+    types: PropTypes.object,
+    marks: PropTypes.object,
+
+    // Less common overrides
+    list: PropTypes.func,
+    listItem: PropTypes.func,
+
+    // Low-level serializers
+    block: PropTypes.func,
+    span: PropTypes.func
+  }),
+
+  blocks: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.shape({
+    _type: PropTypes.string.isRequired
+  })), PropTypes.shape({
+    _type: PropTypes.string.isRequired
+  })]).isRequired
+};
+
+SanityBlockContent.defaultProps = {
+  renderContainerOnSingleChild: false,
+  serializers: {},
+  imageOptions: {}
+};
+
+var BlockContent = SanityBlockContent;
+
+export { BlockContent as B };