@mjhls/mjh-framework 1.0.44 → 1.0.45

package/dist/index.js

@@ -25,7 +25,6 @@ var Button = _interopDefault(require('react-bootstrap/Button'));
 var router = require('next/router');
 var PropTypes = _interopDefault(require('prop-types'));
 var reactBootstrap = require('react-bootstrap');
-var BlockContent = _interopDefault(require('@sanity/block-content-to-react'));
 
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation. All rights reserved.
@@ -5632,39 +5631,24 @@ var AD728x90 = function AD728x90(_ref) {
       adUnit = _ref.adUnit,
       slotId = _ref.slotId,
       _ref$targeting = _ref.targeting,
-      targeting = _ref$targeting === undefined ? { desktop: {}, mobile: { post: 'mobile1' } } : _ref$targeting;
-
-  console.log('targeting:', targeting);
+      targeting = _ref$targeting === undefined ? {} : _ref$targeting;
 
   return React__default.createElement(
     lib_1,
-    { dfpNetworkId: networkID, targetingArguments: targeting.desktop, sizeMapping: [{ viewport: [1024, 768], sizes: [[728, 90]] }, { viewport: [640, 480], sizes: [[320, 50], [300, 50]] }], lazyLoad: { fetchMarginPercent: 500, renderMarginPercent: 200, mobileScaling: 2.0 } },
-    React__default.createElement(
-      main_2,
-      null,
-      React__default.createElement(
-        'div',
-        { className: 'AD728x90' },
-        React__default.createElement(lib_2, {
-          slotId: slotId,
-          sizes: [[728, 90]],
-          adUnit: adUnit
-        })
-      )
-    ),
+    {
+      dfpNetworkId: networkID,
+      targetingArguments: targeting.desktop,
+      sizeMapping: [{ viewport: [768, 1], sizes: [[728, 90]] }, { viewport: [1, 1], sizes: [[320, 50], [300, 50]] }],
+      lazyLoad: { fetchMarginPercent: 500, renderMarginPercent: 200, mobileScaling: 2.0 } },
     React__default.createElement(
-      main_8,
-      null,
-      React__default.createElement(
-        'div',
-        { className: 'AD728x90' },
-        React__default.createElement(lib_2, {
-          slotId: slotId,
-          sizes: [[300, 50], [320, 50]],
-          adUnit: adUnit,
-          targetingArguments: targeting.mobile
-        })
-      )
+      'div',
+      { className: 'AD728x90' },
+      React__default.createElement(lib_2, {
+        slotId: slotId,
+        sizes: [[728, 90], [320, 50], [300, 50]],
+        adUnit: adUnit,
+        sizeMapping: [{ viewport: [768, 1], sizes: [[728, 90]] }, { viewport: [1, 1], sizes: [[320, 50], [300, 50]] }]
+      })
     )
   );
 };
@@ -8468,6 +8452,1447 @@ var YouTubePlayer$1 = function YouTubePlayer(_ref) {
   return React__default.createElement(YouTube, { videoId: id, opts: { width: '100%' } });
 };
 
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+/* eslint-disable no-unused-vars */
+var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+var hasOwnProperty$5 = 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$5.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 parseAssetId_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+var example = 'image-Tb9Ew8CXIwaY6R1kjMvI0uRR-2000x3000-jpg';
+function parseAssetId(ref) {
+    var _a = ref.split('-'), id = _a[1], dimensionString = _a[2], format = _a[3];
+    if (!id || !dimensionString || !format) {
+        throw new Error("Malformed asset _ref '" + ref + "'. Expected an id like \"" + example + "\".");
+    }
+    var _b = dimensionString.split('x'), imgWidthStr = _b[0], imgHeightStr = _b[1];
+    var width = +imgWidthStr;
+    var height = +imgHeightStr;
+    var isValidAssetId = isFinite(width) && isFinite(height);
+    if (!isValidAssetId) {
+        throw new Error("Malformed asset _ref '" + ref + "'. Expected an id like \"" + example + "\".");
+    }
+    return { id: id, width: width, height: height, format: format };
+}
+exports.default = parseAssetId;
+
+});
+
+unwrapExports(parseAssetId_1);
+
+var parseSource_1 = createCommonjsModule(function (module, exports) {
+var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var isRef = function (src) {
+    var source = src;
+    return source ? typeof source._ref === 'string' : false;
+};
+var isAsset = function (src) {
+    var source = src;
+    return source ? typeof source._id === 'string' : false;
+};
+var isAssetStub = function (src) {
+    var source = src;
+    return source && source.asset ? typeof source.asset.url === 'string' : false;
+};
+// Convert an asset-id, asset or image to an image record suitable for processing
+// eslint-disable-next-line complexity
+function parseSource(source) {
+    if (!source) {
+        return null;
+    }
+    var image;
+    if (typeof source === 'string' && isUrl(source)) {
+        // Someone passed an existing image url?
+        image = {
+            asset: { _ref: urlToId(source) }
+        };
+    }
+    else if (typeof source === 'string') {
+        // Just an asset id
+        image = {
+            asset: { _ref: source }
+        };
+    }
+    else if (isRef(source)) {
+        // We just got passed an asset directly
+        image = {
+            asset: source
+        };
+    }
+    else if (isAsset(source)) {
+        // If we were passed an image asset document
+        image = {
+            asset: {
+                _ref: source._id || ''
+            }
+        };
+    }
+    else if (isAssetStub(source)) {
+        // If we were passed a partial asset (`url`, but no `_id`)
+        image = {
+            asset: {
+                _ref: urlToId(source.asset.url)
+            }
+        };
+    }
+    else if (typeof source.asset === 'object') {
+        // Probably an actual image with materialized asset
+        image = source;
+    }
+    else {
+        // We got something that does not look like an image, or it is an image
+        // that currently isn't sporting an asset.
+        return null;
+    }
+    var img = source;
+    if (img.crop) {
+        image.crop = img.crop;
+    }
+    if (img.hotspot) {
+        image.hotspot = img.hotspot;
+    }
+    return applyDefaults(image);
+}
+exports.default = parseSource;
+function isUrl(url) {
+    return /^https?:\/\//.test("" + url);
+}
+function urlToId(url) {
+    var parts = url.split('/').slice(-1);
+    return ("image-" + parts[0]).replace(/\.([a-z]+)$/, '-$1');
+}
+// Mock crop and hotspot if image lacks it
+function applyDefaults(image) {
+    if (image.crop && image.hotspot) {
+        return image;
+    }
+    // We need to pad in default values for crop or hotspot
+    var result = __assign({}, image);
+    if (!result.crop) {
+        result.crop = {
+            left: 0,
+            top: 0,
+            bottom: 0,
+            right: 0
+        };
+    }
+    if (!result.hotspot) {
+        result.hotspot = {
+            x: 0.5,
+            y: 0.5,
+            height: 1.0,
+            width: 1.0
+        };
+    }
+    return result;
+}
+
+});
+
+unwrapExports(parseSource_1);
+
+var urlForImage_1 = createCommonjsModule(function (module, exports) {
+var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var parseAssetId_1$$1 = __importDefault(parseAssetId_1);
+var parseSource_1$$1 = __importDefault(parseSource_1);
+exports.parseSource = parseSource_1$$1.default;
+exports.SPEC_NAME_TO_URL_NAME_MAPPINGS = [
+    ['width', 'w'],
+    ['height', 'h'],
+    ['format', 'fm'],
+    ['download', 'dl'],
+    ['blur', 'blur'],
+    ['sharpen', 'sharp'],
+    ['invert', 'invert'],
+    ['orientation', 'or'],
+    ['minHeight', 'min-h'],
+    ['maxHeight', 'max-h'],
+    ['minWidth', 'min-w'],
+    ['maxWidth', 'max-w'],
+    ['quality', 'q'],
+    ['fit', 'fit'],
+    ['crop', 'crop'],
+    ['auto', 'auto'],
+    ['dpr', 'dpr']
+];
+function urlForImage(options) {
+    var spec = __assign({}, (options || {}));
+    var source = spec.source;
+    delete spec.source;
+    var image = parseSource_1$$1.default(source);
+    if (!image) {
+        return null;
+    }
+    var id = image.asset._ref || image.asset._id || '';
+    var asset = parseAssetId_1$$1.default(id);
+    // Compute crop rect in terms of pixel coordinates in the raw source image
+    var cropLeft = Math.round(image.crop.left * asset.width);
+    var cropTop = Math.round(image.crop.top * asset.height);
+    var crop = {
+        left: cropLeft,
+        top: cropTop,
+        width: Math.round(asset.width - image.crop.right * asset.width - cropLeft),
+        height: Math.round(asset.height - image.crop.bottom * asset.height - cropTop)
+    };
+    // Compute hot spot rect in terms of pixel coordinates
+    var hotSpotVerticalRadius = (image.hotspot.height * asset.height) / 2;
+    var hotSpotHorizontalRadius = (image.hotspot.width * asset.width) / 2;
+    var hotSpotCenterX = image.hotspot.x * asset.width;
+    var hotSpotCenterY = image.hotspot.y * asset.height;
+    var hotspot = {
+        left: hotSpotCenterX - hotSpotHorizontalRadius,
+        top: hotSpotCenterY - hotSpotVerticalRadius,
+        right: hotSpotCenterX + hotSpotHorizontalRadius,
+        bottom: hotSpotCenterY + hotSpotVerticalRadius
+    };
+    // If irrelevant, or if we are requested to: don't perform crop/fit based on
+    // the crop/hotspot.
+    if (!(spec.rect || spec.focalPoint || spec.ignoreImageParams || spec.crop)) {
+        spec = __assign({}, spec, fit({ crop: crop, hotspot: hotspot }, spec));
+    }
+    return specToImageUrl(__assign({}, spec, { asset: asset }));
+}
+exports.default = urlForImage;
+// eslint-disable-next-line complexity
+function specToImageUrl(spec) {
+    var cdnUrl = spec.baseUrl || 'https://cdn.sanity.io';
+    var filename = spec.asset.id + "-" + spec.asset.width + "x" + spec.asset.height + "." + spec.asset.format;
+    var baseUrl = cdnUrl + "/images/" + spec.projectId + "/" + spec.dataset + "/" + filename;
+    var params = [];
+    if (spec.rect) {
+        // Only bother url with a crop if it actually crops anything
+        var _a = spec.rect, left = _a.left, top_1 = _a.top, width = _a.width, height = _a.height;
+        var isEffectiveCrop = left !== 0 || top_1 !== 0 || height !== spec.asset.height || width !== spec.asset.width;
+        if (isEffectiveCrop) {
+            params.push("rect=" + left + "," + top_1 + "," + width + "," + height);
+        }
+    }
+    if (spec.bg) {
+        params.push("bg=" + spec.bg);
+    }
+    if (spec.focalPoint) {
+        params.push("fp-x=" + spec.focalPoint.x);
+        params.push("fp-x=" + spec.focalPoint.y);
+    }
+    var flip = [spec.flipHorizontal && 'h', spec.flipVertical && 'v'].filter(Boolean).join('');
+    if (flip) {
+        params.push("flip=" + flip);
+    }
+    // Map from spec name to url param name, and allow using the actual param name as an alternative
+    exports.SPEC_NAME_TO_URL_NAME_MAPPINGS.forEach(function (mapping) {
+        var specName = mapping[0], param = mapping[1];
+        if (typeof spec[specName] !== 'undefined') {
+            params.push(param + "=" + encodeURIComponent(spec[specName]));
+        }
+        else if (typeof spec[param] !== 'undefined') {
+            params.push(param + "=" + encodeURIComponent(spec[param]));
+        }
+    });
+    if (params.length === 0) {
+        return baseUrl;
+    }
+    return baseUrl + "?" + params.join('&');
+}
+function fit(source, spec) {
+    var cropRect;
+    var imgWidth = spec.width;
+    var imgHeight = spec.height;
+    // If we are not constraining the aspect ratio, we'll just use the whole crop
+    if (!(imgWidth && imgHeight)) {
+        return { width: imgWidth, height: imgHeight, rect: source.crop };
+    }
+    var crop = source.crop;
+    var hotspot = source.hotspot;
+    // If we are here, that means aspect ratio is locked and fitting will be a bit harder
+    var desiredAspectRatio = imgWidth / imgHeight;
+    var cropAspectRatio = crop.width / crop.height;
+    if (cropAspectRatio > desiredAspectRatio) {
+        // The crop is wider than the desired aspect ratio. That means we are cutting from the sides
+        var height = crop.height;
+        var width = height * desiredAspectRatio;
+        var top_2 = crop.top;
+        // Center output horizontally over hotspot
+        var hotspotXCenter = (hotspot.right - hotspot.left) / 2 + hotspot.left;
+        var left = hotspotXCenter - width / 2;
+        // Keep output within crop
+        if (left < crop.left) {
+            left = crop.left;
+        }
+        else if (left + width > crop.left + crop.width) {
+            left = crop.left + crop.width - width;
+        }
+        cropRect = {
+            left: Math.round(left),
+            top: Math.round(top_2),
+            width: Math.round(width),
+            height: Math.round(height)
+        };
+    }
+    else {
+        // The crop is taller than the desired ratio, we are cutting from top and bottom
+        var width = crop.width;
+        var height = width / desiredAspectRatio;
+        var left = crop.left;
+        // Center output vertically over hotspot
+        var hotspotYCenter = (hotspot.bottom - hotspot.top) / 2 + hotspot.top;
+        var top_3 = hotspotYCenter - height / 2;
+        // Keep output rect within crop
+        if (top_3 < crop.top) {
+            top_3 = crop.top;
+        }
+        else if (top_3 + height > crop.top + crop.height) {
+            top_3 = crop.top + crop.height - height;
+        }
+        cropRect = {
+            left: Math.max(0, Math.floor(left)),
+            top: Math.max(0, Math.floor(top_3)),
+            width: Math.round(width),
+            height: Math.round(height)
+        };
+    }
+    return {
+        width: imgWidth,
+        height: imgHeight,
+        rect: cropRect
+    };
+}
+
+});
+
+unwrapExports(urlForImage_1);
+var urlForImage_2 = urlForImage_1.parseSource;
+var urlForImage_3 = urlForImage_1.SPEC_NAME_TO_URL_NAME_MAPPINGS;
+
+var builder = createCommonjsModule(function (module, exports) {
+var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var urlForImage_1$$1 = __importStar(urlForImage_1);
+var validFits = ['clip', 'crop', 'fill', 'fillmax', 'max', 'scale', 'min'];
+var validCrops = ['top', 'bottom', 'left', 'right', 'center', 'focalpoint', 'entropy'];
+var validAutoModes = ['format'];
+function isSanityClient(client) {
+    return client ? typeof client.clientConfig === 'object' : false;
+}
+function rewriteSpecName(key) {
+    var specs = urlForImage_1$$1.SPEC_NAME_TO_URL_NAME_MAPPINGS;
+    for (var _i = 0, specs_1 = specs; _i < specs_1.length; _i++) {
+        var entry = specs_1[_i];
+        var specName = entry[0], param = entry[1];
+        if (key === specName || key === param) {
+            return specName;
+        }
+    }
+    return key;
+}
+function urlBuilder(options) {
+    // Did we get a SanityClient?
+    var client = options;
+    if (isSanityClient(client)) {
+        // Inherit config from client
+        var _a = client.clientConfig, apiHost = _a.apiHost, projectId = _a.projectId, dataset = _a.dataset;
+        return new ImageUrlBuilder(null, {
+            baseUrl: apiHost.replace(/^https:\/\/api\./, 'https://cdn.'),
+            projectId: projectId,
+            dataset: dataset
+        });
+    }
+    // Or just accept the options as given
+    return new ImageUrlBuilder(null, options);
+}
+exports.default = urlBuilder;
+var ImageUrlBuilder = /** @class */ (function () {
+    function ImageUrlBuilder(parent, options) {
+        this.options = parent
+            ? __assign({}, (parent.options || {}), (options || {})) : __assign({}, (options || {})); // Copy options
+    }
+    ImageUrlBuilder.prototype.withOptions = function (options) {
+        var baseUrl = options.baseUrl || '';
+        var newOptions = { baseUrl: baseUrl };
+        for (var key in options) {
+            if (options.hasOwnProperty(key)) {
+                var specKey = rewriteSpecName(key);
+                newOptions[specKey] = options[key];
+            }
+        }
+        return new ImageUrlBuilder(this, __assign({ baseUrl: baseUrl }, newOptions));
+    };
+    // The image to be represented. Accepts a Sanity 'image'-document, 'asset'-document or
+    // _id of asset. To get the benefit of automatic hot-spot/crop integration with the content
+    // studio, the 'image'-document must be provided.
+    ImageUrlBuilder.prototype.image = function (source) {
+        return this.withOptions({ source: source });
+    };
+    // Specify the dataset
+    ImageUrlBuilder.prototype.dataset = function (dataset) {
+        return this.withOptions({ dataset: dataset });
+    };
+    // Specify the projectId
+    ImageUrlBuilder.prototype.projectId = function (projectId) {
+        return this.withOptions({ projectId: projectId });
+    };
+    // Specify background color
+    ImageUrlBuilder.prototype.bg = function (bg) {
+        return this.withOptions({ bg: bg });
+    };
+    // Set DPR scaling factor
+    ImageUrlBuilder.prototype.dpr = function (dpr) {
+        return this.withOptions({ dpr: dpr });
+    };
+    // Specify the width of the image in pixels
+    ImageUrlBuilder.prototype.width = function (width) {
+        return this.withOptions({ width: width });
+    };
+    // Specify the height of the image in pixels
+    ImageUrlBuilder.prototype.height = function (height) {
+        return this.withOptions({ height: height });
+    };
+    // Specify focal point in fraction of image dimensions. Each component 0.0-1.0
+    ImageUrlBuilder.prototype.focalPoint = function (x, y) {
+        return this.withOptions({ focalPoint: { x: x, y: y } });
+    };
+    ImageUrlBuilder.prototype.maxWidth = function (maxWidth) {
+        return this.withOptions({ maxWidth: maxWidth });
+    };
+    ImageUrlBuilder.prototype.minWidth = function (minWidth) {
+        return this.withOptions({ minWidth: minWidth });
+    };
+    ImageUrlBuilder.prototype.maxHeight = function (maxHeight) {
+        return this.withOptions({ maxHeight: maxHeight });
+    };
+    ImageUrlBuilder.prototype.minHeight = function (minHeight) {
+        return this.withOptions({ minHeight: minHeight });
+    };
+    // Specify width and height in pixels
+    ImageUrlBuilder.prototype.size = function (width, height) {
+        return this.withOptions({ width: width, height: height });
+    };
+    // Specify blur between 0 and 100
+    ImageUrlBuilder.prototype.blur = function (blur) {
+        return this.withOptions({ blur: blur });
+    };
+    ImageUrlBuilder.prototype.sharpen = function (sharpen) {
+        return this.withOptions({ sharpen: sharpen });
+    };
+    // Specify the desired rectangle of the image
+    ImageUrlBuilder.prototype.rect = function (left, top, width, height) {
+        return this.withOptions({ rect: { left: left, top: top, width: width, height: height } });
+    };
+    // Specify the image format of the image. 'jpg', 'pjpg', 'png', 'webp'
+    ImageUrlBuilder.prototype.format = function (format) {
+        return this.withOptions({ format: format });
+    };
+    ImageUrlBuilder.prototype.invert = function (invert) {
+        return this.withOptions({ invert: invert });
+    };
+    // Rotation in degrees 0, 90, 180, 270
+    ImageUrlBuilder.prototype.orientation = function (orientation) {
+        return this.withOptions({ orientation: orientation });
+    };
+    // Compression quality 0-100
+    ImageUrlBuilder.prototype.quality = function (quality) {
+        return this.withOptions({ quality: quality });
+    };
+    // Make it a download link. Parameter is default filename.
+    ImageUrlBuilder.prototype.forceDownload = function (download) {
+        return this.withOptions({ download: download });
+    };
+    // Flip image horizontally
+    ImageUrlBuilder.prototype.flipHorizontal = function () {
+        return this.withOptions({ flipHorizontal: true });
+    };
+    // Flip image verically
+    ImageUrlBuilder.prototype.flipVertical = function () {
+        return this.withOptions({ flipVertical: true });
+    };
+    // Ignore crop/hotspot from image record, even when present
+    ImageUrlBuilder.prototype.ignoreImageParams = function () {
+        return this.withOptions({ ignoreImageParams: true });
+    };
+    ImageUrlBuilder.prototype.fit = function (value) {
+        if (validFits.indexOf(value) === -1) {
+            throw new Error("Invalid fit mode \"" + value + "\"");
+        }
+        return this.withOptions({ fit: value });
+    };
+    ImageUrlBuilder.prototype.crop = function (value) {
+        if (validCrops.indexOf(value) === -1) {
+            throw new Error("Invalid crop mode \"" + value + "\"");
+        }
+        return this.withOptions({ crop: value });
+    };
+    ImageUrlBuilder.prototype.auto = function (value) {
+        if (validAutoModes.indexOf(value) === -1) {
+            throw new Error("Invalid auto mode \"" + value + "\"");
+        }
+        return this.withOptions({ auto: value });
+    };
+    // Gets the url based on the submitted parameters
+    ImageUrlBuilder.prototype.url = function () {
+        return urlForImage_1$$1.default(this.options);
+    };
+    // Synonym for url()
+    ImageUrlBuilder.prototype.toString = function () {
+        return this.url();
+    };
+    return ImageUrlBuilder;
+}());
+
+});
+
+unwrapExports(builder);
+
+var node$1 = createCommonjsModule(function (module) {
+var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var builder_1 = __importDefault(builder);
+module.exports = builder_1.default;
+
+});
+
+unwrapExports(node$1);
+
+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 = props.node,
+      options = props.options;
+  var projectId = options.projectId,
+      dataset = options.dataset;
+  var asset = node.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$1(objectAssign({
+    projectId: projectId,
+    dataset: dataset
+  }, options.imageOptions || {})).image(node).toString();
+};
+
+var getImageUrl = buildUrl;
+
+var serializers = 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(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$1(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1 = function _typeof(obj) { return typeof obj; }; } else { _typeof$1 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1(obj); }
+
+
+
+var isDefined = function isDefined(val) {
+  return typeof val !== 'undefined';
+}; // Recursively merge/replace default serializers with user-specified serializers
+
+
+var mergeSerializers = function mergeSerializers(defaultSerializers, userSerializers) {
+  return Object.keys(defaultSerializers).reduce(function (acc, key) {
+    var type = _typeof$1(defaultSerializers[key]);
+
+    if (type === 'function') {
+      acc[key] = isDefined(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$1 = function isDefined(val) {
+  return typeof val !== 'undefined';
+};
+
+var defaults$1 = {
+  imageOptions: {}
+};
+
+function blocksToNodes(h, properties, defaultSerializers, serializeSpan) {
+  var props = objectAssign({}, defaults$1, 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(defaultSerializers, props.serializers || {});
+  var options = optionProps.reduce(function (opts, key) {
+    var value = props[key];
+
+    if (isDefined$1(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;
+
+var internals = {
+  blocksToNodes: function blocksToNodes(renderNode, props, defaultSerializers, serializeSpan) {
+    if (defaultSerializers) {
+      return blocksToNodes_1(renderNode, props, defaultSerializers, serializeSpan);
+    } // Backwards-compatibility
+
+
+    var serializers$$1 = serializers(renderNode);
+    return blocksToNodes_1(renderNode, props, serializers$$1.defaultSerializers, serializers$$1.serializeSpan);
+  },
+  getSerializers: serializers,
+  getImageUrl: getImageUrl,
+  mergeSerializers: mergeSerializers
+};
+
+var internals$1 = internals;
+
+var getSerializers = internals$1.getSerializers;
+
+var renderNode = React__default.createElement;
+
+var _getSerializers = getSerializers(renderNode),
+    defaultSerializers = _getSerializers.defaultSerializers,
+    serializeSpan = _getSerializers.serializeSpan;
+
+var dom = {
+  serializeSpan: serializeSpan,
+  serializers: defaultSerializers,
+  renderProps: { nestMarks: true }
+};
+
+var serializers$1 = dom.serializers,
+    serializeSpan$1 = dom.serializeSpan,
+    renderProps = dom.renderProps;
+
+var getImageUrl$1 = internals$1.getImageUrl,
+    blocksToNodes$1 = internals$1.blocksToNodes,
+    mergeSerializers$1 = internals$1.mergeSerializers;
+
+var renderNode$1 = React__default.createElement;
+
+var SanityBlockContent = function SanityBlockContent(props) {
+  var customSerializers = mergeSerializers$1(SanityBlockContent.defaultSerializers, props.serializers);
+
+  var blockProps = Object.assign({}, renderProps, props, {
+    serializers: customSerializers,
+    blocks: props.blocks || []
+  });
+
+  return blocksToNodes$1(renderNode$1, blockProps, serializers$1, serializeSpan$1);
+};
+
+// Expose default serializers to the user
+SanityBlockContent.defaultSerializers = serializers$1;
+
+// Expose logic for building image URLs from an image reference/node
+SanityBlockContent.getImageUrl = getImageUrl$1;
+
+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;
+
 var Sidebar = function Sidebar(_ref) {
   var caption = _ref.caption,
       content = _ref.content;
@@ -8488,7 +9913,7 @@ var Sidebar = function Sidebar(_ref) {
   );
 };
 
-var getSerializers = function getSerializers(client) {
+var getSerializers$1 = function getSerializers(client) {
   return {
     types: {
       youtube: function youtube(_ref) {
@@ -8539,6 +9964,6 @@ exports.TemplateNormal = TemplateNormal;
 exports.AD300x250 = AD300x250;
 exports.AD300x250x600 = AD300x250x600;
 exports.AD728x90 = AD728x90;
-exports.getSerializers = getSerializers;
+exports.getSerializers = getSerializers$1;
 exports.Search = Search$1;
 //# sourceMappingURL=index.js.map