@20minutes/draft-convert 3.0.2 → 3.1.0

package/esm/convertToHTML.js

@@ -10,98 +10,76 @@ import blockTypeObjectFunction from './util/blockTypeObjectFunction';
 import getBlockTags from './util/getBlockTags';
 import getNestedBlockTags from './util/getNestedBlockTags';
 import defaultBlockHTML from './default/defaultBlockHTML';
-var defaultEntityToHTML = function defaultEntityToHTML(entity, originalText) {
-  return originalText;
-};
-var defaultValidateHTML = function defaultValidateHTML(html) {
-  return true;
-};
-var convertToHTML = function convertToHTML(_ref) {
-  var _ref$styleToHTML = _ref.styleToHTML,
-    styleToHTML = _ref$styleToHTML === void 0 ? {} : _ref$styleToHTML,
-    _ref$blockToHTML = _ref.blockToHTML,
-    blockToHTML = _ref$blockToHTML === void 0 ? {} : _ref$blockToHTML,
-    _ref$entityToHTML = _ref.entityToHTML,
-    entityToHTML = _ref$entityToHTML === void 0 ? defaultEntityToHTML : _ref$entityToHTML,
-    _ref$validateHTML = _ref.validateHTML,
-    validateHTML = _ref$validateHTML === void 0 ? defaultValidateHTML : _ref$validateHTML;
-  return function (contentState) {
-    invariant(contentState !== null && contentState !== undefined, 'Expected contentState to be non-null');
-    var getBlockHTML;
-    if (blockToHTML.__isMiddleware === true) {
-      getBlockHTML = blockToHTML(blockTypeObjectFunction(defaultBlockHTML));
-    } else {
-      getBlockHTML = accumulateFunction(blockTypeObjectFunction(blockToHTML), blockTypeObjectFunction(defaultBlockHTML));
-    }
-    var rawState = convertToRaw(contentState);
-    var listStack = [];
-    var result = rawState.blocks.map(function (block) {
-      var type = block.type,
-        depth = block.depth;
-      var closeNestTags = '';
-      var openNestTags = '';
-      var blockHTMLResult = getBlockHTML(block);
-      if (!blockHTMLResult) {
-        throw new Error("convertToHTML: missing HTML definition for block with type ".concat(block.type));
-      }
-      if (!blockHTMLResult.nest) {
-        // this block can't be nested, so reset all nesting if necessary
-        closeNestTags = listStack.reduceRight(function (string, nestedBlock) {
-          return string + getNestedBlockTags(getBlockHTML(nestedBlock), depth).nestEnd;
-        }, '');
-        listStack = [];
-      } else {
-        while (depth + 1 !== listStack.length || type !== listStack[depth].type) {
-          if (depth + 1 === listStack.length) {
-            // depth is right but doesn't match type
-            var blockToClose = listStack[depth];
-            closeNestTags += getNestedBlockTags(getBlockHTML(blockToClose), depth).nestEnd;
-            openNestTags += getNestedBlockTags(getBlockHTML(block), depth).nestStart;
-            listStack[depth] = block;
-          } else if (depth + 1 < listStack.length) {
-            var _blockToClose = listStack[listStack.length - 1];
-            closeNestTags += getNestedBlockTags(getBlockHTML(_blockToClose), depth).nestEnd;
-            listStack = listStack.slice(0, -1);
-          } else {
-            openNestTags += getNestedBlockTags(getBlockHTML(block), depth).nestStart;
-            listStack.push(block);
-          }
-        }
-      }
-      var innerHTML = blockInlineStyles(blockEntities(encodeBlock(block), rawState.entityMap, entityToHTML), styleToHTML);
-      var blockHTML = getBlockTags(getBlockHTML(block));
-      var html;
-      if (typeof blockHTML === 'string') {
-        html = blockHTML;
-      } else {
-        html = blockHTML.start + innerHTML + blockHTML.end;
-      }
-      if (innerHTML.length === 0 && Object.prototype.hasOwnProperty.call(blockHTML, 'empty')) {
-        if (/*#__PURE__*/React.isValidElement(blockHTML.empty)) {
-          html = ReactDOMServer.renderToStaticMarkup(blockHTML.empty);
+const defaultEntityToHTML = (entity, originalText)=>originalText;
+const defaultValidateHTML = (html)=>true;
+const convertToHTML = ({ styleToHTML = {}, blockToHTML = {}, entityToHTML = defaultEntityToHTML, validateHTML = defaultValidateHTML })=>(contentState)=>{
+        invariant(contentState !== null && contentState !== undefined, 'Expected contentState to be non-null');
+        let getBlockHTML;
+        if (blockToHTML.__isMiddleware === true) {
+            getBlockHTML = blockToHTML(blockTypeObjectFunction(defaultBlockHTML));
         } else {
-          html = blockHTML.empty;
+            getBlockHTML = accumulateFunction(blockTypeObjectFunction(blockToHTML), blockTypeObjectFunction(defaultBlockHTML));
         }
-      }
-      var finalHtml = closeNestTags + openNestTags + html;
-      if (!validateHTML(finalHtml)) {
-        return '';
-      }
-      return finalHtml;
-    }).join('');
-    result = listStack.reduce(function (res, nestBlock) {
-      return res + getNestedBlockTags(getBlockHTML(nestBlock), nestBlock.depth).nestEnd;
-    }, result);
-    return result;
-  };
-};
-export default (function () {
-  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-    args[_key] = arguments[_key];
-  }
-  if (args.length === 1 && Object.prototype.hasOwnProperty.call(args[0], '_map') && args[0].getBlockMap != null) {
-    // skip higher-order function and use defaults
-    return convertToHTML({}).apply(void 0, args);
-  }
-  return convertToHTML.apply(void 0, args);
-});
+        const rawState = convertToRaw(contentState);
+        let listStack = [];
+        let result = rawState.blocks.map((block)=>{
+            const { type, depth } = block;
+            let closeNestTags = '';
+            let openNestTags = '';
+            const blockHTMLResult = getBlockHTML(block);
+            if (!blockHTMLResult) {
+                throw new Error(`convertToHTML: missing HTML definition for block with type ${block.type}`);
+            }
+            if (!blockHTMLResult.nest) {
+                // this block can't be nested, so reset all nesting if necessary
+                closeNestTags = listStack.reduceRight((string, nestedBlock)=>string + getNestedBlockTags(getBlockHTML(nestedBlock), depth).nestEnd, '');
+                listStack = [];
+            } else {
+                while(depth + 1 !== listStack.length || type !== listStack[depth].type){
+                    if (depth + 1 === listStack.length) {
+                        // depth is right but doesn't match type
+                        const blockToClose = listStack[depth];
+                        closeNestTags += getNestedBlockTags(getBlockHTML(blockToClose), depth).nestEnd;
+                        openNestTags += getNestedBlockTags(getBlockHTML(block), depth).nestStart;
+                        listStack[depth] = block;
+                    } else if (depth + 1 < listStack.length) {
+                        const blockToClose = listStack[listStack.length - 1];
+                        closeNestTags += getNestedBlockTags(getBlockHTML(blockToClose), depth).nestEnd;
+                        listStack = listStack.slice(0, -1);
+                    } else {
+                        openNestTags += getNestedBlockTags(getBlockHTML(block), depth).nestStart;
+                        listStack.push(block);
+                    }
+                }
+            }
+            const innerHTML = blockInlineStyles(blockEntities(encodeBlock(block), rawState.entityMap, entityToHTML), styleToHTML);
+            const blockHTML = getBlockTags(getBlockHTML(block));
+            let html;
+            if (typeof blockHTML === 'string') {
+                html = blockHTML;
+            } else {
+                html = blockHTML.start + innerHTML + blockHTML.end;
+            }
+            if (innerHTML.length === 0 && Object.prototype.hasOwnProperty.call(blockHTML, 'empty')) {
+                if (/*#__PURE__*/ React.isValidElement(blockHTML.empty)) {
+                    html = ReactDOMServer.renderToStaticMarkup(blockHTML.empty);
+                } else {
+                    html = blockHTML.empty;
+                }
+            }
+            const finalHtml = closeNestTags + openNestTags + html;
+            if (!validateHTML(finalHtml)) {
+                return '';
+            }
+            return finalHtml;
+        }).join('');
+        result = listStack.reduce((res, nestBlock)=>res + getNestedBlockTags(getBlockHTML(nestBlock), nestBlock.depth).nestEnd, result);
+        return result;
+    };
+export default ((...args)=>{
+    if (args.length === 1 && Object.prototype.hasOwnProperty.call(args[0], '_map') && args[0].getBlockMap != null) {
+        // skip higher-order function and use defaults
+        return convertToHTML({})(...args);
+    }
+    return convertToHTML(...args);
+});

package/esm/default/defaultBlockHTML.js

@@ -1,33 +1,36 @@
 import React from 'react';
-
 // based on Draft.js' custom list depth styling
-var ORDERED_LIST_TYPES = ['1', 'a', 'i'];
+const ORDERED_LIST_TYPES = [
+    '1',
+    'a',
+    'i'
+];
 export default {
-  unstyled: /*#__PURE__*/React.createElement("p", null),
-  paragraph: /*#__PURE__*/React.createElement("p", null),
-  'header-one': /*#__PURE__*/React.createElement("h1", null),
-  'header-two': /*#__PURE__*/React.createElement("h2", null),
-  'header-two-unordered': /*#__PURE__*/React.createElement("h2", null),
-  'header-two-ordered': /*#__PURE__*/React.createElement("h2", null),
-  'header-three': /*#__PURE__*/React.createElement("h3", null),
-  'header-four': /*#__PURE__*/React.createElement("h4", null),
-  'header-five': /*#__PURE__*/React.createElement("h5", null),
-  'header-six': /*#__PURE__*/React.createElement("h6", null),
-  'code-block': /*#__PURE__*/React.createElement("pre", null),
-  blockquote: /*#__PURE__*/React.createElement("blockquote", null),
-  'unordered-list-item': {
-    element: /*#__PURE__*/React.createElement("li", null),
-    nest: /*#__PURE__*/React.createElement("ul", null)
-  },
-  'ordered-list-item': {
-    element: /*#__PURE__*/React.createElement("li", null),
-    nest: function nest(depth) {
-      var type = ORDERED_LIST_TYPES[depth % 3];
-      return /*#__PURE__*/React.createElement("ol", {
-        type: type
-      });
-    }
-  },
-  media: /*#__PURE__*/React.createElement("figure", null),
-  atomic: /*#__PURE__*/React.createElement("figure", null)
-};
+    unstyled: /*#__PURE__*/ React.createElement("p", null),
+    paragraph: /*#__PURE__*/ React.createElement("p", null),
+    'header-one': /*#__PURE__*/ React.createElement("h1", null),
+    'header-two': /*#__PURE__*/ React.createElement("h2", null),
+    'header-two-unordered': /*#__PURE__*/ React.createElement("h2", null),
+    'header-two-ordered': /*#__PURE__*/ React.createElement("h2", null),
+    'header-three': /*#__PURE__*/ React.createElement("h3", null),
+    'header-four': /*#__PURE__*/ React.createElement("h4", null),
+    'header-five': /*#__PURE__*/ React.createElement("h5", null),
+    'header-six': /*#__PURE__*/ React.createElement("h6", null),
+    'code-block': /*#__PURE__*/ React.createElement("pre", null),
+    blockquote: /*#__PURE__*/ React.createElement("blockquote", null),
+    'unordered-list-item': {
+        element: /*#__PURE__*/ React.createElement("li", null),
+        nest: /*#__PURE__*/ React.createElement("ul", null)
+    },
+    'ordered-list-item': {
+        element: /*#__PURE__*/ React.createElement("li", null),
+        nest: (depth)=>{
+            const type = ORDERED_LIST_TYPES[depth % 3];
+            return /*#__PURE__*/ React.createElement("ol", {
+                type: type
+            });
+        }
+    },
+    media: /*#__PURE__*/ React.createElement("figure", null),
+    atomic: /*#__PURE__*/ React.createElement("figure", null)
+};

package/esm/default/defaultInlineHTML.js

@@ -1,18 +1,18 @@
 import React from 'react';
 export default function defaultInlineHTML(style) {
-  switch (style) {
-    case 'BOLD':
-      return /*#__PURE__*/React.createElement("strong", null);
-    case 'ITALIC':
-      return /*#__PURE__*/React.createElement("em", null);
-    case 'UNDERLINE':
-      return /*#__PURE__*/React.createElement("u", null);
-    case 'CODE':
-      return /*#__PURE__*/React.createElement("code", null);
-    default:
-      return {
-        start: '',
-        end: ''
-      };
-  }
-}
+    switch(style){
+        case 'BOLD':
+            return /*#__PURE__*/ React.createElement("strong", null);
+        case 'ITALIC':
+            return /*#__PURE__*/ React.createElement("em", null);
+        case 'UNDERLINE':
+            return /*#__PURE__*/ React.createElement("u", null);
+        case 'CODE':
+            return /*#__PURE__*/ React.createElement("code", null);
+        default:
+            return {
+                start: '',
+                end: ''
+            };
+    }
+}

package/esm/encodeBlock.js

@@ -1,44 +1,40 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import updateMutation from './util/updateMutation';
 import rangeSort from './util/rangeSort';
-var ENTITY_MAP = {
-  '&': '&amp;',
-  '<': '&lt;',
-  '>': '&gt;',
-  '"': '&quot;',
-  "'": '&#x27;',
-  '`': '&#x60;',
-  '\n': '<br/>'
+const ENTITY_MAP = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#x27;',
+    '`': '&#x60;',
+    '\n': '<br/>'
 };
-export default (function (block) {
-  var blockText = _toConsumableArray(block.text);
-  var entities = block.entityRanges.sort(rangeSort);
-  var styles = block.inlineStyleRanges.sort(rangeSort);
-  var resultText = '';
-  var _loop = function _loop() {
-    var _char = blockText[index];
-    if (ENTITY_MAP[_char] !== undefined) {
-      var encoded = ENTITY_MAP[_char];
-      var resultIndex = _toConsumableArray(resultText).length;
-      resultText += encoded;
-      var updateForChar = function updateForChar(mutation) {
-        return updateMutation(mutation, resultIndex, _char.length, encoded.length, 0, 0);
-      };
-      entities = entities.map(updateForChar);
-      styles = styles.map(updateForChar);
-    } else {
-      resultText += _char;
+export default ((block)=>{
+    const blockText = [
+        ...block.text
+    ];
+    let entities = block.entityRanges.sort(rangeSort);
+    let styles = block.inlineStyleRanges.sort(rangeSort);
+    let resultText = '';
+    for(let index = 0; index < blockText.length; index += 1){
+        const char = blockText[index];
+        if (ENTITY_MAP[char] !== undefined) {
+            const encoded = ENTITY_MAP[char];
+            const resultIndex = [
+                ...resultText
+            ].length;
+            resultText += encoded;
+            const updateForChar = (mutation)=>updateMutation(mutation, resultIndex, char.length, encoded.length, 0, 0);
+            entities = entities.map(updateForChar);
+            styles = styles.map(updateForChar);
+        } else {
+            resultText += char;
+        }
     }
-  };
-  for (var index = 0; index < blockText.length; index += 1) {
-    _loop();
-  }
-  return _objectSpread(_objectSpread({}, block), {}, {
-    text: resultText,
-    inlineStyleRanges: styles,
-    entityRanges: entities
-  });
-});
+    return {
+        ...block,
+        text: resultText,
+        inlineStyleRanges: styles,
+        entityRanges: entities
+    };
+});

package/esm/index.js

@@ -1,4 +1,4 @@
 import convertToHTML from './convertToHTML';
 import convertFromHTML from './convertFromHTML';
 import parseHTML from './util/parseHTML';
-export { convertToHTML, convertFromHTML, parseHTML };
+export { convertToHTML, convertFromHTML, parseHTML };

package/esm/util/accumulateFunction.js

@@ -1,9 +1,7 @@
-export default (function (newFn, rest) {
-  return function () {
-    var newResult = newFn.apply(void 0, arguments);
-    if (newResult !== undefined && newResult !== null) {
-      return newResult;
-    }
-    return rest.apply(void 0, arguments);
-  };
-});
+export default ((newFn, rest)=>(...args)=>{
+        const newResult = newFn(...args);
+        if (newResult !== undefined && newResult !== null) {
+            return newResult;
+        }
+        return rest(...args);
+    });

package/esm/util/blockTypeObjectFunction.js

@@ -1,9 +1,7 @@
-export default (function (typeObject) {
-  return function (block) {
-    if (typeof typeObject === 'function') {
-      // handle case where typeObject is already a function
-      return typeObject(block);
-    }
-    return typeObject[block.type];
-  };
-});
+export default ((typeObject)=>(block)=>{
+        if (typeof typeObject === 'function') {
+            // handle case where typeObject is already a function
+            return typeObject(block);
+        }
+        return typeObject[block.type];
+    });

package/esm/util/getBlockTags.js

@@ -1,27 +1,27 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import invariant from 'invariant';
 import React from 'react';
 import ReactDOMServer from 'react-dom/server';
 import splitReactElement from './splitReactElement';
 function hasChildren(element) {
-  return /*#__PURE__*/React.isValidElement(element) && React.Children.count(element.props.children) > 0;
+    return /*#__PURE__*/ React.isValidElement(element) && React.Children.count(element.props.children) > 0;
 }
 export default function getBlockTags(blockHTML) {
-  invariant(blockHTML !== null && blockHTML !== undefined, 'Expected block HTML value to be non-null');
-  if (typeof blockHTML === 'string') {
-    return blockHTML;
-  }
-  if (/*#__PURE__*/React.isValidElement(blockHTML)) {
-    if (hasChildren(blockHTML)) {
-      return ReactDOMServer.renderToStaticMarkup(blockHTML);
+    invariant(blockHTML !== null && blockHTML !== undefined, 'Expected block HTML value to be non-null');
+    if (typeof blockHTML === 'string') {
+        return blockHTML;
+    }
+    if (/*#__PURE__*/ React.isValidElement(blockHTML)) {
+        if (hasChildren(blockHTML)) {
+            return ReactDOMServer.renderToStaticMarkup(blockHTML);
+        }
+        return splitReactElement(blockHTML);
+    }
+    if (Object.prototype.hasOwnProperty.call(blockHTML, 'element') && /*#__PURE__*/ React.isValidElement(blockHTML.element)) {
+        return {
+            ...blockHTML,
+            ...splitReactElement(blockHTML.element)
+        };
     }
-    return splitReactElement(blockHTML);
-  }
-  if (Object.prototype.hasOwnProperty.call(blockHTML, 'element') && /*#__PURE__*/React.isValidElement(blockHTML.element)) {
-    return _objectSpread(_objectSpread({}, blockHTML), splitReactElement(blockHTML.element));
-  }
-  invariant(Object.prototype.hasOwnProperty.call(blockHTML, 'start') && Object.prototype.hasOwnProperty.call(blockHTML, 'end'), 'convertToHTML: received block information without either a ReactElement or an object with start/end tags');
-  return blockHTML;
-}
+    invariant(Object.prototype.hasOwnProperty.call(blockHTML, 'start') && Object.prototype.hasOwnProperty.call(blockHTML, 'end'), 'convertToHTML: received block information without either a ReactElement or an object with start/end tags');
+    return blockHTML;
+}

package/esm/util/getElementHTML.js

@@ -1,36 +1,32 @@
-import _typeof from "@babel/runtime/helpers/esm/typeof";
 import invariant from 'invariant';
 import React from 'react';
 import ReactDOMServer from 'react-dom/server';
 import splitReactElement from './splitReactElement';
 function hasChildren(element) {
-  return /*#__PURE__*/React.isValidElement(element) && React.Children.count(element.props.children) > 0;
+    return /*#__PURE__*/ React.isValidElement(element) && React.Children.count(element.props.children) > 0;
 }
-export default function getElementHTML(element) {
-  var text = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-  if (element === undefined || element === null) {
-    return element;
-  }
-  if (typeof element === 'string') {
-    return element;
-  }
-  if (/*#__PURE__*/React.isValidElement(element)) {
-    if (hasChildren(element)) {
-      return ReactDOMServer.renderToStaticMarkup(element);
+export default function getElementHTML(element, text = null) {
+    if (element === undefined || element === null) {
+        return element;
+    }
+    if (typeof element === 'string') {
+        return element;
     }
-    var tags = splitReactElement(element);
-    if (text !== null && _typeof(tags) === 'object') {
-      var start = tags.start,
-        end = tags.end;
-      return start + text + end;
+    if (/*#__PURE__*/ React.isValidElement(element)) {
+        if (hasChildren(element)) {
+            return ReactDOMServer.renderToStaticMarkup(element);
+        }
+        const tags = splitReactElement(element);
+        if (text !== null && typeof tags === 'object') {
+            const { start, end } = tags;
+            return start + text + end;
+        }
+        return tags;
     }
-    return tags;
-  }
-  invariant(Object.prototype.hasOwnProperty.call(element, 'start') && Object.prototype.hasOwnProperty.call(element, 'end'), 'convertToHTML: received conversion data without either an HTML string, ReactElement or an object with start/end tags');
-  if (text !== null) {
-    var _start = element.start,
-      _end = element.end;
-    return _start + text + _end;
-  }
-  return element;
-}
+    invariant(Object.prototype.hasOwnProperty.call(element, 'start') && Object.prototype.hasOwnProperty.call(element, 'end'), 'convertToHTML: received conversion data without either an HTML string, ReactElement or an object with start/end tags');
+    if (text !== null) {
+        const { start, end } = element;
+        return start + text + end;
+    }
+    return element;
+}

package/esm/util/getElementTagLength.js

@@ -1,20 +1,18 @@
-import _typeof from "@babel/runtime/helpers/esm/typeof";
 import React from 'react';
 import splitReactElement from './splitReactElement';
-var _getElementTagLength = function getElementTagLength(element) {
-  var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'start';
-  if (/*#__PURE__*/React.isValidElement(element)) {
-    var splitElement = splitReactElement(element);
-    if (typeof splitElement === 'string') {
-      return 0;
+const getElementTagLength = (element, type = 'start')=>{
+    if (/*#__PURE__*/ React.isValidElement(element)) {
+        const splitElement = splitReactElement(element);
+        if (typeof splitElement === 'string') {
+            return 0;
+        }
+        const { length } = splitElement[type];
+        const child = React.Children.toArray(element.props.children)[0];
+        return length + (child && /*#__PURE__*/ React.isValidElement(child) ? getElementTagLength(child, type) : 0);
     }
-    var length = splitElement[type].length;
-    var child = React.Children.toArray(element.props.children)[0];
-    return length + (child && /*#__PURE__*/React.isValidElement(child) ? _getElementTagLength(child, type) : 0);
-  }
-  if (_typeof(element) === 'object') {
-    return element[type] ? element[type].length : 0;
-  }
-  return 0;
+    if (typeof element === 'object') {
+        return element[type] ? element[type].length : 0;
+    }
+    return 0;
 };
-export default _getElementTagLength;
+export default getElementTagLength;

package/esm/util/getNestedBlockTags.js

@@ -1,29 +1,24 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import invariant from 'invariant';
 import React from 'react';
 import splitReactElement from './splitReactElement';
 export default function getNestedBlockTags(blockHTML, depth) {
-  invariant(blockHTML !== null && blockHTML !== undefined, 'Expected block HTML value to be non-null');
-  if (typeof blockHTML.nest === 'function') {
-    var _splitReactElement = splitReactElement(blockHTML.nest(depth)),
-      start = _splitReactElement.start,
-      end = _splitReactElement.end;
-    return _objectSpread(_objectSpread({}, blockHTML), {}, {
-      nestStart: start,
-      nestEnd: end
-    });
-  }
-  if (/*#__PURE__*/React.isValidElement(blockHTML.nest)) {
-    var _splitReactElement2 = splitReactElement(blockHTML.nest),
-      _start = _splitReactElement2.start,
-      _end = _splitReactElement2.end;
-    return _objectSpread(_objectSpread({}, blockHTML), {}, {
-      nestStart: _start,
-      nestEnd: _end
-    });
-  }
-  invariant(Object.prototype.hasOwnProperty.call(blockHTML, 'nestStart') && Object.prototype.hasOwnProperty.call(blockHTML, 'nestEnd'), 'convertToHTML: received block information without either a ReactElement or an object with start/end tags');
-  return blockHTML;
-}
+    invariant(blockHTML !== null && blockHTML !== undefined, 'Expected block HTML value to be non-null');
+    if (typeof blockHTML.nest === 'function') {
+        const { start, end } = splitReactElement(blockHTML.nest(depth));
+        return {
+            ...blockHTML,
+            nestStart: start,
+            nestEnd: end
+        };
+    }
+    if (/*#__PURE__*/ React.isValidElement(blockHTML.nest)) {
+        const { start, end } = splitReactElement(blockHTML.nest);
+        return {
+            ...blockHTML,
+            nestStart: start,
+            nestEnd: end
+        };
+    }
+    invariant(Object.prototype.hasOwnProperty.call(blockHTML, 'nestStart') && Object.prototype.hasOwnProperty.call(blockHTML, 'nestEnd'), 'convertToHTML: received block information without either a ReactElement or an object with start/end tags');
+    return blockHTML;
+}

package/esm/util/parseHTML.js

@@ -1,18 +1,18 @@
-var fallback = function fallback(html) {
-  var doc = document.implementation.createHTMLDocument('');
-  doc.documentElement.innerHTML = html;
-  return doc;
+const fallback = (html)=>{
+    const doc = document.implementation.createHTMLDocument('');
+    doc.documentElement.innerHTML = html;
+    return doc;
 };
 export default function parseHTML(html) {
-  var doc;
-  if (typeof DOMParser !== 'undefined') {
-    var parser = new DOMParser();
-    doc = parser.parseFromString(html, 'text/html');
-    if (doc === null || doc.body === null) {
-      doc = fallback(html);
+    let doc;
+    if (typeof DOMParser !== 'undefined') {
+        const parser = new DOMParser();
+        doc = parser.parseFromString(html, 'text/html');
+        if (doc === null || doc.body === null) {
+            doc = fallback(html);
+        }
+    } else {
+        doc = fallback(html);
     }
-  } else {
-    doc = fallback(html);
-  }
-  return doc.body;
-}
+    return doc.body;
+}