@20minutes/draft-convert 3.0.2 → 3.1.0

package/esm/util/rangeSort.js

@@ -1,6 +1,6 @@
-export default (function (r1, r2) {
-  if (r1.offset === r2.offset) {
-    return r2.length - r1.length;
-  }
-  return r1.offset - r2.offset;
-});
+export default ((r1, r2)=>{
+    if (r1.offset === r2.offset) {
+        return r2.length - r1.length;
+    }
+    return r1.offset - r2.offset;
+});

package/esm/util/splitReactElement.js

@@ -1,18 +1,32 @@
 import invariant from 'invariant';
 import React from 'react';
 import ReactDOMServer from 'react-dom/server';
-
 // see http://w3c.github.io/html/syntax.html#writing-html-documents-elements
-var VOID_TAGS = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
+const VOID_TAGS = [
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr'
+];
 export default function splitReactElement(element) {
-  if (VOID_TAGS.indexOf(element.type) !== -1) {
-    return ReactDOMServer.renderToStaticMarkup(element);
-  }
-  var tags = ReactDOMServer.renderToStaticMarkup(/*#__PURE__*/React.cloneElement(element, {}, '\r')).split('\r');
-  invariant(tags.length > 1, "convertToHTML: Element of type ".concat(element.type, " must render children"));
-  invariant(tags.length < 3, "convertToHTML: Element of type ".concat(element.type, " cannot use carriage return character"));
-  return {
-    start: tags[0],
-    end: tags[1]
-  };
-}
+    if (VOID_TAGS.indexOf(element.type) !== -1) {
+        return ReactDOMServer.renderToStaticMarkup(element);
+    }
+    const tags = ReactDOMServer.renderToStaticMarkup(/*#__PURE__*/ React.cloneElement(element, {}, '\r')).split('\r');
+    invariant(tags.length > 1, `convertToHTML: Element of type ${element.type} must render children`);
+    invariant(tags.length < 3, `convertToHTML: Element of type ${element.type} cannot use carriage return character`);
+    return {
+        start: tags[0],
+        end: tags[1]
+    };
+}

package/esm/util/styleObjectFunction.js

@@ -1,8 +1,6 @@
-export default (function (object) {
-  return function (style) {
-    if (typeof object === 'function') {
-      return object(style);
-    }
-    return object[style];
-  };
-});
+export default ((object)=>(style)=>{
+        if (typeof object === 'function') {
+            return object(style);
+        }
+        return object[style];
+    });

package/esm/util/updateMutation.js

@@ -1,48 +1,58 @@
-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; }
 export default function updateMutation(mutation, originalOffset, originalLength, newLength, prefixLength, suffixLength) {
-  // three cases we can reasonably adjust - disjoint mutations that
-  // happen later on where the offset will need to be changed,
-  // mutations that completely contain the new one where we can adjust
-  // the length, and mutations that occur partially within the new one.
-  var lengthDiff = newLength - originalLength;
-  var mutationAfterChange = originalOffset + originalLength <= mutation.offset;
-  if (mutationAfterChange) {
-    return _objectSpread(_objectSpread({}, mutation), {}, {
-      offset: mutation.offset + lengthDiff
-    });
-  }
-  var mutationContainsChange = originalOffset >= mutation.offset && originalOffset + originalLength <= mutation.offset + mutation.length;
-  if (mutationContainsChange) {
-    return _objectSpread(_objectSpread({}, mutation), {}, {
-      length: mutation.length + lengthDiff
-    });
-  }
-  var mutationWithinPrefixChange = mutation.offset >= originalOffset && mutation.offset + mutation.length <= originalOffset + originalLength && prefixLength > 0;
-  if (mutationWithinPrefixChange) {
-    return _objectSpread(_objectSpread({}, mutation), {}, {
-      offset: mutation.offset + prefixLength
-    });
-  }
-  var mutationContainsPrefix = mutation.offset < originalOffset && mutation.offset + mutation.length <= originalOffset + originalLength && mutation.offset + mutation.length > originalOffset && prefixLength > 0;
-  if (mutationContainsPrefix) {
-    return [_objectSpread(_objectSpread({}, mutation), {}, {
-      length: originalOffset - mutation.offset
-    }), _objectSpread(_objectSpread({}, mutation), {}, {
-      offset: originalOffset + prefixLength,
-      length: mutation.offset - originalOffset + mutation.length
-    })];
-  }
-  var mutationContainsSuffix = mutation.offset >= originalOffset && mutation.offset + mutation.length > originalOffset + originalLength && originalOffset + originalLength > mutation.offset && suffixLength > 0;
-  if (mutationContainsSuffix) {
-    return [_objectSpread(_objectSpread({}, mutation), {}, {
-      offset: mutation.offset + prefixLength,
-      length: originalOffset + originalLength - mutation.offset
-    }), _objectSpread(_objectSpread({}, mutation), {}, {
-      offset: originalOffset + originalLength + prefixLength + suffixLength,
-      length: mutation.offset + mutation.length - (originalOffset + originalLength)
-    })];
-  }
-  return mutation;
-}
+    // three cases we can reasonably adjust - disjoint mutations that
+    // happen later on where the offset will need to be changed,
+    // mutations that completely contain the new one where we can adjust
+    // the length, and mutations that occur partially within the new one.
+    const lengthDiff = newLength - originalLength;
+    const mutationAfterChange = originalOffset + originalLength <= mutation.offset;
+    if (mutationAfterChange) {
+        return {
+            ...mutation,
+            offset: mutation.offset + lengthDiff
+        };
+    }
+    const mutationContainsChange = originalOffset >= mutation.offset && originalOffset + originalLength <= mutation.offset + mutation.length;
+    if (mutationContainsChange) {
+        return {
+            ...mutation,
+            length: mutation.length + lengthDiff
+        };
+    }
+    const mutationWithinPrefixChange = mutation.offset >= originalOffset && mutation.offset + mutation.length <= originalOffset + originalLength && prefixLength > 0;
+    if (mutationWithinPrefixChange) {
+        return {
+            ...mutation,
+            offset: mutation.offset + prefixLength
+        };
+    }
+    const mutationContainsPrefix = mutation.offset < originalOffset && mutation.offset + mutation.length <= originalOffset + originalLength && mutation.offset + mutation.length > originalOffset && prefixLength > 0;
+    if (mutationContainsPrefix) {
+        return [
+            {
+                ...mutation,
+                length: originalOffset - mutation.offset
+            },
+            {
+                ...mutation,
+                offset: originalOffset + prefixLength,
+                length: mutation.offset - originalOffset + mutation.length
+            }
+        ];
+    }
+    const mutationContainsSuffix = mutation.offset >= originalOffset && mutation.offset + mutation.length > originalOffset + originalLength && originalOffset + originalLength > mutation.offset && suffixLength > 0;
+    if (mutationContainsSuffix) {
+        return [
+            {
+                ...mutation,
+                offset: mutation.offset + prefixLength,
+                length: originalOffset + originalLength - mutation.offset
+            },
+            {
+                ...mutation,
+                offset: originalOffset + originalLength + prefixLength + suffixLength,
+                length: mutation.offset + mutation.length - (originalOffset + originalLength)
+            }
+        ];
+    }
+    return mutation;
+}

package/lib/blockEntities.js

@@ -1,74 +1,79 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports["default"] = void 0;
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-var _updateMutation = _interopRequireDefault(require("./util/updateMutation"));
-var _rangeSort = _interopRequireDefault(require("./util/rangeSort"));
-var _getElementHTML = _interopRequireDefault(require("./util/getElementHTML"));
-var _getElementTagLength = _interopRequireDefault(require("./util/getElementTagLength"));
-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) { (0, _defineProperty2["default"])(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; }
-var converter = function converter() {
-  var entity = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var originalText = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
-  return originalText;
-};
-var _default = exports["default"] = function _default(block, entityMap) {
-  var entityConverter = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : converter;
-  var resultText = (0, _toConsumableArray2["default"])(block.text);
-  var getEntityHTML = entityConverter;
-  if (entityConverter.__isMiddleware) {
-    getEntityHTML = entityConverter(converter);
-  }
-  if (Object.prototype.hasOwnProperty.call(block, 'entityRanges') && block.entityRanges.length > 0) {
-    var entities = block.entityRanges.sort(_rangeSort["default"]);
-    var styles = block.inlineStyleRanges;
-    var _loop = function _loop(index) {
-      var entityRange = entities[index];
-      var entity = entityMap[entityRange.key];
-      var originalText = resultText.slice(entityRange.offset, entityRange.offset + entityRange.length).join('');
-      var entityHTML = getEntityHTML(entity, originalText);
-      var elementHTML = (0, _getElementHTML["default"])(entityHTML, originalText);
-      var converted;
-      if (!!elementHTML || elementHTML === '') {
-        converted = (0, _toConsumableArray2["default"])(elementHTML);
-      } else {
-        converted = originalText;
-      }
-      var prefixLength = (0, _getElementTagLength["default"])(entityHTML, 'start');
-      var suffixLength = (0, _getElementTagLength["default"])(entityHTML, 'end');
-      var updateLaterMutation = function updateLaterMutation(mutation, mutationIndex) {
-        if (mutationIndex > index || Object.prototype.hasOwnProperty.call(mutation, 'style')) {
-          return (0, _updateMutation["default"])(mutation, entityRange.offset, entityRange.length, converted.length, prefixLength, suffixLength);
-        }
-        return mutation;
-      };
-      var updateLaterMutations = function updateLaterMutations(mutationList) {
-        return mutationList.reduce(function (acc, mutation, mutationIndex) {
-          var updatedMutation = updateLaterMutation(mutation, mutationIndex);
-          if (Array.isArray(updatedMutation)) {
-            return acc.concat(updatedMutation);
-          }
-          return acc.concat([updatedMutation]);
-        }, []);
-      };
-      entities = updateLaterMutations(entities);
-      styles = updateLaterMutations(styles);
-      resultText = [].concat((0, _toConsumableArray2["default"])(resultText.slice(0, entityRange.offset)), (0, _toConsumableArray2["default"])(converted), (0, _toConsumableArray2["default"])(resultText.slice(entityRange.offset + entityRange.length)));
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _updateMutation = /*#__PURE__*/ _interop_require_default(require("./util/updateMutation"));
+const _rangeSort = /*#__PURE__*/ _interop_require_default(require("./util/rangeSort"));
+const _getElementHTML = /*#__PURE__*/ _interop_require_default(require("./util/getElementHTML"));
+const _getElementTagLength = /*#__PURE__*/ _interop_require_default(require("./util/getElementTagLength"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
     };
-    for (var index = 0; index < entities.length; index += 1) {
-      _loop(index);
+}
+const converter = (entity = {}, originalText = '')=>originalText;
+const _default = (block, entityMap, entityConverter = converter)=>{
+    let resultText = [
+        ...block.text
+    ];
+    let getEntityHTML = entityConverter;
+    if (entityConverter.__isMiddleware) {
+        getEntityHTML = entityConverter(converter);
     }
-    return _objectSpread(_objectSpread({}, block), {}, {
-      text: resultText.join(''),
-      inlineStyleRanges: styles,
-      entityRanges: entities
-    });
-  }
-  return block;
-};
+    if (Object.prototype.hasOwnProperty.call(block, 'entityRanges') && block.entityRanges.length > 0) {
+        let entities = block.entityRanges.sort(_rangeSort.default);
+        let styles = block.inlineStyleRanges;
+        for(let index = 0; index < entities.length; index += 1){
+            const entityRange = entities[index];
+            const entity = entityMap[entityRange.key];
+            const originalText = resultText.slice(entityRange.offset, entityRange.offset + entityRange.length).join('');
+            const entityHTML = getEntityHTML(entity, originalText);
+            const elementHTML = (0, _getElementHTML.default)(entityHTML, originalText);
+            let converted;
+            if (!!elementHTML || elementHTML === '') {
+                converted = [
+                    ...elementHTML
+                ];
+            } else {
+                converted = originalText;
+            }
+            const prefixLength = (0, _getElementTagLength.default)(entityHTML, 'start');
+            const suffixLength = (0, _getElementTagLength.default)(entityHTML, 'end');
+            const updateLaterMutation = (mutation, mutationIndex)=>{
+                if (mutationIndex > index || Object.prototype.hasOwnProperty.call(mutation, 'style')) {
+                    return (0, _updateMutation.default)(mutation, entityRange.offset, entityRange.length, converted.length, prefixLength, suffixLength);
+                }
+                return mutation;
+            };
+            const updateLaterMutations = (mutationList)=>mutationList.reduce((acc, mutation, mutationIndex)=>{
+                    const updatedMutation = updateLaterMutation(mutation, mutationIndex);
+                    if (Array.isArray(updatedMutation)) {
+                        return acc.concat(updatedMutation);
+                    }
+                    return acc.concat([
+                        updatedMutation
+                    ]);
+                }, []);
+            entities = updateLaterMutations(entities);
+            styles = updateLaterMutations(styles);
+            resultText = [
+                ...resultText.slice(0, entityRange.offset),
+                ...converted,
+                ...resultText.slice(entityRange.offset + entityRange.length)
+            ];
+        }
+        return {
+            ...block,
+            text: resultText.join(''),
+            inlineStyleRanges: styles,
+            entityRanges: entities
+        };
+    }
+    return block;
+};

package/lib/blockInlineStyles.js

@@ -1,105 +1,90 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports["default"] = void 0;
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-var _invariant = _interopRequireDefault(require("invariant"));
-var _styleObjectFunction = _interopRequireDefault(require("./util/styleObjectFunction"));
-var _accumulateFunction = _interopRequireDefault(require("./util/accumulateFunction"));
-var _getElementHTML = _interopRequireDefault(require("./util/getElementHTML"));
-var _rangeSort = _interopRequireDefault(require("./util/rangeSort"));
-var _defaultInlineHTML = _interopRequireDefault(require("./default/defaultInlineHTML"));
-var subtractStyles = function subtractStyles(original, toRemove) {
-  return original.filter(function (el) {
-    return !toRemove.some(function (elToRemove) {
-      return elToRemove.style === el.style;
-    });
-  });
-};
-var popEndingStyles = function popEndingStyles(styleStack, endingStyles) {
-  return endingStyles.reduceRight(function (stack, style) {
-    var styleToRemove = stack[stack.length - 1];
-    (0, _invariant["default"])(styleToRemove.style === style.style, "Style ".concat(styleToRemove.style, " to be removed doesn't match expected ").concat(style.style));
-    return stack.slice(0, -1);
-  }, styleStack);
-};
-var characterStyles = function characterStyles(offset, ranges) {
-  return ranges.filter(function (range) {
-    return offset >= range.offset && offset < range.offset + range.length;
-  });
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _invariant = /*#__PURE__*/ _interop_require_default(require("invariant"));
+const _styleObjectFunction = /*#__PURE__*/ _interop_require_default(require("./util/styleObjectFunction"));
+const _accumulateFunction = /*#__PURE__*/ _interop_require_default(require("./util/accumulateFunction"));
+const _getElementHTML = /*#__PURE__*/ _interop_require_default(require("./util/getElementHTML"));
+const _rangeSort = /*#__PURE__*/ _interop_require_default(require("./util/rangeSort"));
+const _defaultInlineHTML = /*#__PURE__*/ _interop_require_default(require("./default/defaultInlineHTML"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const subtractStyles = (original, toRemove)=>original.filter((el)=>!toRemove.some((elToRemove)=>elToRemove.style === el.style));
+const popEndingStyles = (styleStack, endingStyles)=>endingStyles.reduceRight((stack, style)=>{
+        const styleToRemove = stack[stack.length - 1];
+        (0, _invariant.default)(styleToRemove.style === style.style, `Style ${styleToRemove.style} to be removed doesn't match expected ${style.style}`);
+        return stack.slice(0, -1);
+    }, styleStack);
+const characterStyles = (offset, ranges)=>ranges.filter((range)=>offset >= range.offset && offset < range.offset + range.length);
+const rangeIsSubset = (firstRange, secondRange)=>{
+    // returns true if the second range is a subset of the first
+    const secondStartWithinFirst = firstRange.offset <= secondRange.offset;
+    const secondEndWithinFirst = firstRange.offset + firstRange.length >= secondRange.offset + secondRange.length;
+    return secondStartWithinFirst && secondEndWithinFirst;
 };
-var rangeIsSubset = function rangeIsSubset(firstRange, secondRange) {
-  // returns true if the second range is a subset of the first
-  var secondStartWithinFirst = firstRange.offset <= secondRange.offset;
-  var secondEndWithinFirst = firstRange.offset + firstRange.length >= secondRange.offset + secondRange.length;
-  return secondStartWithinFirst && secondEndWithinFirst;
+const latestStyleLast = (s1, s2)=>{
+    // make sure longer-lasting styles are added first
+    const s2endIndex = s2.offset + s2.length;
+    const s1endIndex = s1.offset + s1.length;
+    return s2endIndex - s1endIndex;
 };
-var latestStyleLast = function latestStyleLast(s1, s2) {
-  // make sure longer-lasting styles are added first
-  var s2endIndex = s2.offset + s2.length;
-  var s1endIndex = s1.offset + s1.length;
-  return s2endIndex - s1endIndex;
+const getStylesToReset = (remainingStyles, newStyles)=>{
+    let i = 0;
+    while(i < remainingStyles.length){
+        if (newStyles.every(rangeIsSubset.bind(null, remainingStyles[i]))) {
+            i += 1;
+        } else {
+            return remainingStyles.slice(i);
+        }
+    }
+    return [];
 };
-var getStylesToReset = function getStylesToReset(remainingStyles, newStyles) {
-  var i = 0;
-  while (i < remainingStyles.length) {
-    if (newStyles.every(rangeIsSubset.bind(null, remainingStyles[i]))) {
-      i += 1;
+const appendStartMarkup = (inlineHTML, string, styleRange)=>string + (0, _getElementHTML.default)(inlineHTML(styleRange.style)).start;
+const prependEndMarkup = (inlineHTML, string, styleRange)=>(0, _getElementHTML.default)(inlineHTML(styleRange.style)).end + string;
+const defaultCustomInlineHTML = (next)=>(style)=>next(style);
+defaultCustomInlineHTML.__isMiddleware = true;
+const _default = (rawBlock, customInlineHTML = defaultCustomInlineHTML)=>{
+    (0, _invariant.default)(rawBlock !== null && rawBlock !== undefined, 'Expected raw block to be non-null');
+    let inlineHTML;
+    if (customInlineHTML.__isMiddleware === true) {
+        inlineHTML = customInlineHTML(_defaultInlineHTML.default);
     } else {
-      return remainingStyles.slice(i);
+        inlineHTML = (0, _accumulateFunction.default)((0, _styleObjectFunction.default)(customInlineHTML), (0, _styleObjectFunction.default)(_defaultInlineHTML.default));
     }
-  }
-  return [];
-};
-var appendStartMarkup = function appendStartMarkup(inlineHTML, string, styleRange) {
-  return string + (0, _getElementHTML["default"])(inlineHTML(styleRange.style)).start;
-};
-var prependEndMarkup = function prependEndMarkup(inlineHTML, string, styleRange) {
-  return (0, _getElementHTML["default"])(inlineHTML(styleRange.style)).end + string;
-};
-var defaultCustomInlineHTML = function defaultCustomInlineHTML(next) {
-  return function (style) {
-    return next(style);
-  };
+    let result = '';
+    let styleStack = [];
+    const sortedRanges = rawBlock.inlineStyleRanges.sort(_rangeSort.default);
+    const originalTextArray = [
+        ...rawBlock.text
+    ];
+    for(let i = 0; i < originalTextArray.length; i += 1){
+        const styles = characterStyles(i, sortedRanges);
+        const endingStyles = subtractStyles(styleStack, styles);
+        const newStyles = subtractStyles(styles, styleStack);
+        const remainingStyles = subtractStyles(styleStack, endingStyles);
+        // reset styles: look for any already existing styles that will need to
+        // end before styles that are being added on this character. to solve this
+        // close out those current tags and all nested children,
+        // then open new ones nested within the new styles.
+        const resetStyles = getStylesToReset(remainingStyles, newStyles);
+        const openingStyles = resetStyles.concat(newStyles).sort(latestStyleLast);
+        const openingStyleTags = openingStyles.reduce(appendStartMarkup.bind(null, inlineHTML), '');
+        const endingStyleTags = endingStyles.concat(resetStyles).reduce(prependEndMarkup.bind(null, inlineHTML), '');
+        result += endingStyleTags + openingStyleTags + originalTextArray[i];
+        styleStack = popEndingStyles(styleStack, resetStyles.concat(endingStyles));
+        styleStack = styleStack.concat(openingStyles);
+        (0, _invariant.default)(styleStack.length === styles.length, `Character ${i}: ${styleStack.length - styles.length} styles left on stack that should no longer be there`);
+    }
+    result = styleStack.reduceRight((res, openStyle)=>res + (0, _getElementHTML.default)(inlineHTML(openStyle.style)).end, result);
+    return result;
 };
-defaultCustomInlineHTML.__isMiddleware = true;
-var _default = exports["default"] = function _default(rawBlock) {
-  var customInlineHTML = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultCustomInlineHTML;
-  (0, _invariant["default"])(rawBlock !== null && rawBlock !== undefined, 'Expected raw block to be non-null');
-  var inlineHTML;
-  if (customInlineHTML.__isMiddleware === true) {
-    inlineHTML = customInlineHTML(_defaultInlineHTML["default"]);
-  } else {
-    inlineHTML = (0, _accumulateFunction["default"])((0, _styleObjectFunction["default"])(customInlineHTML), (0, _styleObjectFunction["default"])(_defaultInlineHTML["default"]));
-  }
-  var result = '';
-  var styleStack = [];
-  var sortedRanges = rawBlock.inlineStyleRanges.sort(_rangeSort["default"]);
-  var originalTextArray = (0, _toConsumableArray2["default"])(rawBlock.text);
-  for (var i = 0; i < originalTextArray.length; i += 1) {
-    var styles = characterStyles(i, sortedRanges);
-    var endingStyles = subtractStyles(styleStack, styles);
-    var newStyles = subtractStyles(styles, styleStack);
-    var remainingStyles = subtractStyles(styleStack, endingStyles);
-
-    // reset styles: look for any already existing styles that will need to
-    // end before styles that are being added on this character. to solve this
-    // close out those current tags and all nested children,
-    // then open new ones nested within the new styles.
-    var resetStyles = getStylesToReset(remainingStyles, newStyles);
-    var openingStyles = resetStyles.concat(newStyles).sort(latestStyleLast);
-    var openingStyleTags = openingStyles.reduce(appendStartMarkup.bind(null, inlineHTML), '');
-    var endingStyleTags = endingStyles.concat(resetStyles).reduce(prependEndMarkup.bind(null, inlineHTML), '');
-    result += endingStyleTags + openingStyleTags + originalTextArray[i];
-    styleStack = popEndingStyles(styleStack, resetStyles.concat(endingStyles));
-    styleStack = styleStack.concat(openingStyles);
-    (0, _invariant["default"])(styleStack.length === styles.length, "Character ".concat(i, ": ").concat(styleStack.length - styles.length, " styles left on stack that should no longer be there"));
-  }
-  result = styleStack.reduceRight(function (res, openStyle) {
-    return res + (0, _getElementHTML["default"])(inlineHTML(openStyle.style)).end;
-  }, result);
-  return result;
-};