@seafile/sdoc-editor 0.1.59 → 0.1.61

package/dist/basic-sdk/editor.js

@@ -1,5 +1,5 @@
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import React, { useCallback, useEffect, useMemo, useState, useRef } from 'react';
 import { Node } from '@seafile/slate';
 import { Editable, Slate, ReactEditor } from '@seafile/slate-react';
 import defaultEditor, { renderLeaf, renderElement, Toolbar, ContextMenu } from './extension';
@@ -19,6 +19,8 @@ import './assets/css/sdoc-editor-plugins.css';
 var SDocEditor = function SDocEditor(_ref) {
   var document = _ref.document,
     config = _ref.config;
+  var articleRef = useRef(null);
+
   // init editor
   var editor = useMemo(function () {
     var newEditor = withNodeId(withSocketIO(defaultEditor, {
@@ -57,6 +59,7 @@ var SDocEditor = function SDocEditor(_ref) {
   // useMount: init socket connection
   useEffect(function () {
     editor.openConnection();
+    editor.width = articleRef.current.children[0].clientWidth;
     return function () {
       editor.closeConnection();
     };
@@ -111,7 +114,8 @@ var SDocEditor = function SDocEditor(_ref) {
     value: slateValue,
     onChange: onChange
   }, /*#__PURE__*/React.createElement("div", {
-    className: "article"
+    className: "article",
+    ref: articleRef
   }, /*#__PURE__*/React.createElement(SetNodeToDecorations, null), /*#__PURE__*/React.createElement(Editable, {
     renderElement: renderElement,
     renderLeaf: renderLeaf,

package/dist/basic-sdk/extension/constants/index.js

@@ -113,4 +113,12 @@ export var TABLE_ELEMENT_POSITION = {
   AFTER: 'after',
   BEFORE: 'before'
 };
+export var DELETED_STYLE = {
+  background_color: '#ffeef0',
+  color: 'rgb(165, 32, 21)'
+};
+export var ADDED_STYLE = {
+  background_color: '#e6ffed',
+  color: 'rgb(137, 181, 66)'
+};
 export { BLOCKQUOTE, HEADER, HEADER1, HEADER2, HEADER3, HEADER4, HEADER5, HEADER6, PARAGRAPH, BOLD, ITALIC, UNDERLINE, STRIKETHROUGH, ORDERED_LIST, UNORDERED_LIST, LIST_ITEM, LIST_LIC, CHECK_LIST, CHECK_LIST_ITEM, LINK, HTML, CODE_BLOCK, CODE_LINE, IMAGE, TABLE, TABLE_CELL, TABLE_ROW, FORMULA, COLUMN, TEXT_STYLE, BOLD_ITALIC, TEXT_ALIGN, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ELEMENT_TYPE, KEYBOARD };

package/dist/basic-sdk/extension/core/utils/index.js

@@ -18,13 +18,16 @@ export var match = function match(node, path, predicate) {
   }
   return predicate(node, path);
 };
+export var generateDefaultText = function generateDefaultText() {
+  return {
+    id: slugid.nice(),
+    text: ''
+  };
+};
 export var generateEmptyElement = function generateEmptyElement(type) {
   return {
     type: type,
-    children: [{
-      id: slugid.nice(),
-      text: ''
-    }]
+    children: [generateDefaultText()]
   };
 };
 export function Placeholder(props) {

package/dist/basic-sdk/extension/menu/menu.css

@@ -8,7 +8,8 @@
 
 .menu-group .menu-group-item {
   width: 30px;
-  height: 100%;
+  height: 30px;
+  line-height: 30px;
   margin-right: 10px;
   border: 1px solid transparent;
   color: #555555;

package/dist/basic-sdk/extension/plugins/code-block/helpers.js

@@ -68,7 +68,8 @@ export var changeToCodeBlock = function changeToCodeBlock(editor, language) {
       id: slugid.nice(),
       type: CODE_LINE,
       children: [{
-        text: strArr.join('\n')
+        text: strArr.join('\n'),
+        id: slugid.nice()
       } // Select the plain text of the node
       ]
     }]
@@ -95,8 +96,10 @@ export var changeToPlainText = function changeToPlainText(editor) {
     return {
       type: 'paragraph',
       children: [{
-        text: s
-      }]
+        text: s,
+        id: slugid.nice()
+      }],
+      id: elem.id
     };
   });
   Transforms.insertNodes(editor, pList, {

package/dist/basic-sdk/extension/plugins/code-block/render-elem.js

@@ -99,7 +99,8 @@ var CodeBlock = function CodeBlock(_ref) {
       document.getElementById('sdoc-editor-article-container').removeEventListener('scroll', onScroll);
     }
     return function () {
-      document.getElementById('sdoc-editor-article-container').removeEventListener('scroll', onScroll);
+      var articleContainer = document.getElementById('sdoc-editor-article-container');
+      articleContainer && articleContainer.removeEventListener('scroll', onScroll);
     };
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [showHoverMenu]);

package/dist/basic-sdk/extension/plugins/table/constants/index.js

@@ -6,7 +6,5 @@ export var EMPTY_SELECTED_RANGE = {
   minColIndex: -1,
   maxColIndex: -1
 };
-export var TABLE_MAX_WIDTH = 672; // 673 = 794 - 2[borderLeft + borderRight] - 120[paddingLeft + paddingRight]
-
 export var TABLE_ROW_MIN_HEIGHT = 42;
 export var TABLE_CELL_MIN_WIDTH = 35;

package/dist/basic-sdk/extension/plugins/table/helpers.js

@@ -5,7 +5,7 @@ import slugid from 'slugid';
 import { Editor, Range, Transforms } from '@seafile/slate';
 import { getNodeType, getParentNode, getSelectedNodeByType, isTextNode, getSelectedElems, focusEditor, getNode, findPath } from '../../core';
 import { ELEMENT_TYPE, TABLE_ELEMENT, TABLE_ELEMENT_POSITION } from '../../constants';
-import { TABLE_MAX_ROWS, TABLE_MAX_COLUMNS, EMPTY_SELECTED_RANGE, TABLE_ROW_MIN_HEIGHT, TABLE_CELL_MIN_WIDTH, TABLE_MAX_WIDTH } from './constants';
+import { TABLE_MAX_ROWS, TABLE_MAX_COLUMNS, EMPTY_SELECTED_RANGE, TABLE_ROW_MIN_HEIGHT, TABLE_CELL_MIN_WIDTH } from './constants';
 import EventBus from '../../../utils/event-bus';
 import { EXTERNAL_EVENT } from '../../../../constants';
 import ObjectUtils from '../../../utils/object-utils';
@@ -65,8 +65,8 @@ export var generateTableRow = function generateTableRow(colsCount) {
     }
   };
 };
-export var generateEmptyTable = function generateEmptyTable() {
-  var size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [0, 0];
+export var generateEmptyTable = function generateEmptyTable(editor) {
+  var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0];
   var rowsCount = size[0];
   var colsCount = size[1];
   var children = [];
@@ -74,7 +74,7 @@ export var generateEmptyTable = function generateEmptyTable() {
     var tableRow = generateTableRow(colsCount);
     children.push(tableRow);
   }
-  var columnWidth = Math.max(TABLE_CELL_MIN_WIDTH, parseInt(TABLE_MAX_WIDTH / colsCount));
+  var columnWidth = Math.max(TABLE_CELL_MIN_WIDTH, parseInt(editor.width / colsCount));
   var columns = [];
   for (var _i = 0; _i < colsCount; _i++) {
     columns.push({
@@ -91,7 +91,7 @@ export var generateEmptyTable = function generateEmptyTable() {
 export var insertTable = function insertTable(editor, size, selection) {
   if (!size) return;
   if (isTableMenuDisabled(editor)) return;
-  var tableNode = generateEmptyTable(size);
+  var tableNode = generateEmptyTable(editor, size);
   Transforms.insertNodes(editor, tableNode, {
     at: selection
   });
@@ -351,7 +351,7 @@ export var getTableColumnsAfterInsertColumn = function getTableColumnsAfterInser
   var targetInsertColumnsWidth = targetColumn.width * insertColumnCount;
 
   // Currently in scrolling state, insert directly
-  if (totalColumnsWidth > TABLE_MAX_WIDTH) {
+  if (totalColumnsWidth > editor.width) {
     for (var i = 0; i < insertColumnCount; i++) {
       newColumns.splice(targetColumnIndex, 0, targetColumn);
     }
@@ -360,7 +360,7 @@ export var getTableColumnsAfterInsertColumn = function getTableColumnsAfterInser
 
   // Not currently scrolling
   // It is not a scroll state after inserting a new column
-  if (totalColumnsWidth + targetInsertColumnsWidth < TABLE_MAX_WIDTH) {
+  if (totalColumnsWidth + targetInsertColumnsWidth < editor.width) {
     for (var _i5 = 0; _i5 < insertColumnCount; _i5++) {
       newColumns.push(targetColumn);
     }
@@ -372,7 +372,7 @@ export var getTableColumnsAfterInsertColumn = function getTableColumnsAfterInser
     totalColumnsWidth += targetColumn.width;
     newColumns.splice(targetColumnIndex, 0, targetColumn);
   }
-  var proportion = totalColumnsWidth / (TABLE_MAX_WIDTH - 1);
+  var proportion = totalColumnsWidth / (editor.width - 1);
   return newColumns.map(function (column) {
     return _objectSpread(_objectSpread({}, column), {}, {
       width: Math.max(parseInt(column.width / proportion), TABLE_CELL_MIN_WIDTH)
@@ -395,7 +395,7 @@ export var getTableColumns = function getTableColumns(editor, element) {
   var initColumns = [];
   for (var i = 0; i < columnsCount; i++) {
     var column = {
-      width: Math.max(TABLE_CELL_MIN_WIDTH, parseInt(TABLE_MAX_WIDTH / columnsCount))
+      width: Math.max(TABLE_CELL_MIN_WIDTH, parseInt(editor.width / columnsCount))
     };
     initColumns.push(column);
   }
@@ -418,7 +418,7 @@ export var getCellColumn = function getCellColumn(editor, cellElement) {
   } else {
     var columnsCount = tableElement.children[0].children.length;
     column = {
-      width: Math.max(TABLE_CELL_MIN_WIDTH, parseInt(TABLE_MAX_WIDTH / columnsCount))
+      width: Math.max(TABLE_CELL_MIN_WIDTH, parseInt(editor.width / columnsCount))
     };
   }
   return column;

package/dist/basic-sdk/extension/plugins/table/render/render-cell.js

@@ -74,6 +74,7 @@ function renderTableCell(props) {
     var width = column.width;
     return /*#__PURE__*/React.createElement("div", Object.assign({}, attributes, {
       style: _objectSpread(_objectSpread(_objectSpread({}, style), element.style), {}, {
+        minWidth: width,
         width: width
       }),
       className: classnames('table-cell', attributes.className),

package/dist/basic-sdk/extension/plugins/table/render/table-root.js

@@ -1,13 +1,15 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import React, { useState, useRef } from 'react';
+import React, { useState, useRef, useCallback } from 'react';
 import classnames from 'classnames';
-import { TABLE_MAX_WIDTH } from '../constants';
+import { useSlateStatic } from '@seafile/slate-react';
 import { TableRootContext } from './hooks';
 var TableRoot = function TableRoot(_ref) {
   var attributes = _ref.attributes,
     _ref$columns = _ref.columns,
     columns = _ref$columns === void 0 ? [] : _ref$columns,
     children = _ref.children;
+  var editor = useSlateStatic();
   var tableScrollWrapper = useRef(null);
   var _useState = useState(0),
     _useState2 = _slicedToArray(_useState, 2),
@@ -16,19 +18,22 @@ var TableRoot = function TableRoot(_ref) {
   var allWidth = columns.reduce(function (pre, cur) {
     return pre + cur.width;
   }, 0);
-  var onScroll = function onScroll(event) {
+  var onScroll = useCallback(function (event) {
     setScrollLeft(event.target.scrollLeft);
-  };
+  }, []);
   return /*#__PURE__*/React.createElement(TableRootContext.Provider, {
     value: tableScrollWrapper.current
-  }, /*#__PURE__*/React.createElement("div", Object.assign({
-    className: classnames('sdoc-table-wrapper', {
-      'scroll position-relative': allWidth > TABLE_MAX_WIDTH
+  }, /*#__PURE__*/React.createElement("div", Object.assign({}, attributes, {
+    className: classnames('sdoc-table-wrapper', attributes.className, {
+      'scroll position-relative': allWidth > editor.width
+    }),
+    style: _objectSpread(_objectSpread({}, attributes.style), {}, {
+      maxWidth: editor.width
     })
-  }, attributes), /*#__PURE__*/React.createElement("div", {
+  }), /*#__PURE__*/React.createElement("div", {
     className: classnames('sdoc-table-scroll-wrapper', {
-      'scroll-at-center': scrollLeft + TABLE_MAX_WIDTH !== allWidth && scrollLeft > 0,
-      'scroll-at-right': scrollLeft + TABLE_MAX_WIDTH === allWidth,
+      'scroll-at-center': scrollLeft + editor.width !== allWidth && scrollLeft > 0,
+      'scroll-at-right': scrollLeft + editor.width === allWidth,
       'scroll-at-left': scrollLeft === 0
     }),
     ref: tableScrollWrapper,

package/dist/basic-sdk/extension/plugins/text-align/menu/index.js

@@ -70,7 +70,6 @@ var TextAlignMenu = /*#__PURE__*/function (_React$Component) {
     key: "render",
     value: function render() {
       var _this2 = this;
-      var t = this.props.t;
       var isDropdownMenuOpen = this.state.isDropdownMenuOpen;
       var caretIconClass = "caret-icon sdocfont sdoc-".concat(isDropdownMenuOpen ? 'caret-up' : 'drop-down');
       var curType = this.getCurrentType();

package/dist/basic-sdk/extension/plugins/text-align/menu/style.css

@@ -26,6 +26,7 @@
   align-items: center;
   font-size: 14px;
   cursor: pointer;
+  line-height: 1;
 }
 
 .align-menu .align-toggle .caret-icon {

package/dist/basic-sdk/extension/plugins/text-style/render-elem.js

@@ -9,6 +9,18 @@ var renderText = function renderText(props, editor) {
   var text = leaf.text,
     rest = _objectWithoutProperties(leaf, _excluded);
   var markedChildren = React.cloneElement(children);
+  var style = {};
+  if (leaf.isCaret) {
+    style['position'] = 'relative';
+    style['display'] = 'inline-block';
+    style['minWidth'] = '2px';
+  }
+  if (leaf.background_color) {
+    style['backgroundColor'] = leaf.background_color;
+  }
+  if (leaf.color) {
+    style['color'] = leaf.color;
+  }
   if (leaf.BOLD) {
     markedChildren = /*#__PURE__*/React.createElement("strong", null, markedChildren);
   }
@@ -36,20 +48,13 @@ var renderText = function renderText(props, editor) {
     markedChildren = /*#__PURE__*/React.createElement("del", null, markedChildren);
   }
   if (leaf.ADD) {
-    markedChildren = /*#__PURE__*/React.createElement("ins", null, markedChildren);
+    markedChildren = /*#__PURE__*/React.createElement("span", null, markedChildren);
   }
   if (leaf.decoration) {
     markedChildren = /*#__PURE__*/React.createElement("span", {
       className: "token ".concat(leaf.type)
     }, markedChildren);
   }
-  var style = {
-    position: 'relative'
-  };
-  if (leaf.isCaret) {
-    style['display'] = 'inline-block';
-    style['minWidth'] = '2px';
-  }
   return /*#__PURE__*/React.createElement("span", Object.assign({
     "data-id": leaf.id
   }, attributes, {

package/dist/basic-sdk/utils/diff-text.js

@@ -0,0 +1,255 @@
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import ObjectUtils from './object-utils';
+var buildValues = function buildValues(diff, components, newString, oldString, valueType, useLongestToken) {
+  var componentPos = 0;
+  var componentLen = components.length;
+  var newPos = 0;
+  var oldPos = 0;
+  for (; componentPos < componentLen; componentPos++) {
+    var component = components[componentPos];
+    if (!component.removed) {
+      if (!component.added && useLongestToken) {
+        var value = newString.slice(newPos, newPos + component.count);
+        // eslint-disable-next-line no-loop-func
+        value = value.map(function (value, i) {
+          var oldValue = oldString[oldPos + i];
+          return oldValue.length > value.length ? oldValue : value;
+        });
+        component.value = diff.join(value, valueType);
+      } else {
+        component.value = diff.join(newString.slice(newPos, newPos + component.count), valueType);
+      }
+      newPos += component.count;
+
+      // Common case
+      if (!component.added) {
+        oldPos += component.count;
+      }
+    } else {
+      component.value = diff.join(oldString.slice(oldPos, oldPos + component.count), valueType);
+      oldPos += component.count;
+
+      // Reverse add and remove so removes are output first to match common convention
+      // The diffing algorithm is tied to add then remove output and this is the simplest
+      // route to get the desired output with minimal overhead.
+      if (componentPos && components[componentPos - 1].added) {
+        var tmp = components[componentPos - 1];
+        components[componentPos - 1] = components[componentPos];
+        components[componentPos] = tmp;
+      }
+    }
+  }
+
+  // Special case handle for when one terminal is ignored (i.e. whitespace).
+  // For this case we merge the terminal into the prior string and drop the change.
+  // This is only available for string mode.
+  var lastComponent = components[componentLen - 1];
+  if (componentLen > 1 && typeof lastComponent.value === 'string' && (lastComponent.added || lastComponent.removed) && diff.equals('', lastComponent.value)) {
+    components[componentLen - 2].value += lastComponent.value;
+    components.pop();
+  }
+  return components;
+};
+var clonePath = function clonePath(path) {
+  return {
+    newPos: path.newPos,
+    components: path.components.slice(0)
+  };
+};
+var DiffText = /*#__PURE__*/_createClass(function DiffText(oldValue, newValue) {
+  var _this = this;
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  _classCallCheck(this, DiffText);
+  this.done = function (value) {
+    if (_this.callback) {
+      setTimeout(function () {
+        this.callback(undefined, value);
+      }, 0);
+      return true;
+    }
+    return value;
+  };
+  // Main worker method. checks all permutations of a given edit length for acceptance.
+  this.execCompareLength = function (bestPath) {
+    for (var diagonalPath = -1 * _this.comparePath; diagonalPath <= _this.comparePath; diagonalPath += 2) {
+      var basePath = void 0;
+      var addPath = bestPath[diagonalPath - 1];
+      var removePath = bestPath[diagonalPath + 1];
+      var oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
+      if (addPath) {
+        // No one else is going to attempt to use this value, clear it
+        bestPath[diagonalPath - 1] = undefined;
+      }
+      var canAdd = addPath && addPath.newPos + 1 < _this.newLen;
+      var canRemove = removePath && 0 <= oldPos && oldPos < _this.oldLen;
+      if (!canAdd && !canRemove) {
+        // If this path is a terminal then prune
+        bestPath[diagonalPath] = undefined;
+        continue;
+      }
+
+      // Select the diagonal that we want to branch from. We select the prior
+      // path whose position in the new string is the farthest from the origin
+      // and does not pass the bounds of the diff graph
+      if (!canAdd || canRemove && addPath.newPos < removePath.newPos) {
+        basePath = clonePath(removePath);
+        _this.pushComponent(basePath.components, undefined, true);
+      } else {
+        basePath = addPath; // No need to clone, we've pulled it from the list
+        basePath.newPos++;
+        _this.pushComponent(basePath.components, true, undefined);
+      }
+      oldPos = _this.extractCommon(basePath, _this.newValue, _this.oldValue, diagonalPath);
+
+      // If we have hit the end of both strings, then we are done
+      if (basePath.newPos + 1 >= _this.newLen && oldPos + 1 >= _this.oldLen) {
+        return _this.done(buildValues(_this, basePath.components, _this.newValue, _this.oldValue, _this.valueType, _this.useLongestToken));
+      } else {
+        // Otherwise track this path as a potential candidate and continue.
+        bestPath[diagonalPath] = basePath;
+      }
+    }
+    _this.comparePath++;
+  };
+  this.exec = function (bestPath) {
+    setTimeout(function () {
+      if (this.comparePath > this.maxEditLength) {
+        return this.callback();
+      }
+      if (!this.execCompareLength(bestPath)) {
+        this.exec(bestPath);
+      }
+    }, 0);
+  };
+  this.pushComponent = function (components, added, removed) {
+    var last = components[components.length - 1];
+    if (last && last.added === added && last.removed === removed) {
+      // We need to clone here as the component clone operation is just
+      // as shallow array clone
+      components[components.length - 1] = {
+        count: last.count + 1,
+        added: added,
+        removed: removed
+      };
+    } else {
+      components.push({
+        count: 1,
+        added: added,
+        removed: removed
+      });
+    }
+  };
+  this.extractCommon = function (basePath, newString, oldString, diagonalPath) {
+    var newLen = newString.length;
+    var oldLen = oldString.length;
+    var newPos = basePath.newPos;
+    var oldPos = newPos - diagonalPath;
+    var commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && _this.equals(newString[newPos + 1], oldString[oldPos + 1])) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+    }
+    if (commonCount) {
+      basePath.components.push({
+        count: commonCount
+      });
+    }
+    basePath.newPos = newPos;
+    return oldPos;
+  };
+  this.equals = function (left, right) {
+    if (_this.options.comparator) {
+      return _this.options.comparator(left, right);
+    } else {
+      return left === right || _this.options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  };
+  this.removeEmpty = function (array, type) {
+    if (type === 'Array') return array;
+    var ret = [];
+    for (var i = 0; i < array.length; i++) {
+      if (array[i]) {
+        ret.push(array[i]);
+      }
+    }
+    return ret;
+  };
+  this.tokenize = function (value, valueType) {
+    if (valueType === 'Array') return value.slice();
+    return value.split('');
+  };
+  this.join = function (value, valueType) {
+    if (valueType === 'Array') return value;
+    return value.join('');
+  };
+  this.getDiffs = function () {
+    if (!_this.canCompare) {
+      return [{
+        value: _this.oldValue,
+        removed: true
+      }, {
+        value: _this.newValue,
+        added: true
+      }];
+    }
+    var bestPath = [{
+      newPos: -1,
+      components: []
+    }];
+
+    // Seed editLength = 0, i.e. the content starts with the same values
+    var oldPos = _this.extractCommon(bestPath[0], _this.newValue, _this.oldValue, 0);
+    if (bestPath[0].newPos + 1 >= _this.newLen && oldPos + 1 >= _this.oldLen) {
+      // Identity per the equality and tokenizer
+      return _this.done([{
+        value: _this.join(_this.newValue, _this.valueType),
+        count: _this.oldValue.length
+      }]);
+    }
+
+    // Performs the length of edit iteration. Is a bit fugly as this has to support the
+    // sync and async mode which is never fun. Loops over execCompareLength until a value
+    // is produced, or until the edit length exceeds options.maxEditLength (if given),
+    // in which case it will return undefined.
+    if (_this.callback) {
+      _this.exec(bestPath);
+    } else {
+      while (_this.comparePath <= _this.maxEditLength) {
+        var ret = _this.execCompareLength(bestPath);
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  };
+  this.oldValue = oldValue;
+  this.newValue = newValue;
+  var oldValueType = ObjectUtils.getDataType(oldValue);
+  var newValueType = ObjectUtils.getDataType(newValue);
+  this.canCompare = true;
+  if (oldValueType !== newValueType) {
+    this.canCompare = false;
+    return;
+  }
+  this.valueType = newValueType;
+  this.callback = options.callback;
+  var optionsType = ObjectUtils.getDataType(options);
+  if (optionsType === 'function') {
+    this.callback = options;
+    this.options = {};
+  } else {
+    this.options = {};
+  }
+  this.comparePath = 1;
+  this.oldValue = this.removeEmpty(this.tokenize(oldValue, oldValueType), oldValueType);
+  this.oldLen = this.oldValue.length;
+  this.newValue = this.removeEmpty(this.tokenize(newValue, newValueType), newValueType);
+  this.newLen = this.newValue.length;
+  this.maxEditLength = this.newLen + this.oldLen;
+  if (this.options.maxEditLength) {
+    this.maxEditLength = Math.min(this.maxEditLength, this.options.maxEditLength);
+  }
+});
+export default DiffText;