@mjhls/mjh-framework 1.0.99-0.next-12 → 1.0.99

package/dist/esm/BlockContent-c99c9a8d.js

@@ -1,909 +0,0 @@
-import React__default from 'react';
-import PropTypes from 'prop-types';
-import { n as node } from './index-0dbff1d1.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 };