slate/lib/models/text.js

A completely customizable framework for building rich text editors.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _isPlainObject = require('is-plain-object');

var _isPlainObject2 = _interopRequireDefault(_isPlainObject);

var _immutable = require('immutable');

var _character = require('./character');

var _character2 = _interopRequireDefault(_character);

var _mark = require('./mark');

var _mark2 = _interopRequireDefault(_mark);

var _leaf = require('./leaf');

var _leaf2 = _interopRequireDefault(_leaf);

var _modelTypes = require('../constants/model-types');

var _modelTypes2 = _interopRequireDefault(_modelTypes);

var _generateKey = require('../utils/generate-key');

var _generateKey2 = _interopRequireDefault(_generateKey);

var _memoize = require('../utils/memoize');

var _memoize2 = _interopRequireDefault(_memoize);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

/**
 * Default properties.
 *
 * @type {Object}
 */

var DEFAULTS = {
  characters: new _immutable.List(),
  key: undefined
};

/**
 * Text.
 *
 * @type {Text}
 */

var Text = function (_Record) {
  _inherits(Text, _Record);

  function Text() {
    _classCallCheck(this, Text);

    return _possibleConstructorReturn(this, (Text.__proto__ || Object.getPrototypeOf(Text)).apply(this, arguments));
  }

  _createClass(Text, [{
    key: 'addMark',


    /**
     * Add a `mark` at `index` and `length`.
     *
     * @param {Number} index
     * @param {Number} length
     * @param {Mark} mark
     * @return {Text}
     */

    value: function addMark(index, length, mark) {
      var marks = new _immutable.Set([mark]);
      return this.addMarks(index, length, marks);
    }

    /**
     * Add a `set` of marks at `index` and `length`.
     *
     * @param {Number} index
     * @param {Number} length
     * @param {Set<Mark>} set
     * @return {Text}
     */

  }, {
    key: 'addMarks',
    value: function addMarks(index, length, set) {
      var characters = this.characters.map(function (char, i) {
        if (i < index) return char;
        if (i >= index + length) return char;
        var _char = char,
            marks = _char.marks;

        marks = marks.union(set);
        char = char.set('marks', marks);
        return char;
      });

      return this.set('characters', characters);
    }

    /**
     * Derive a set of decorated characters with `decorations`.
     *
     * @param {List<Decoration>} decorations
     * @return {List<Character>}
     */

  }, {
    key: 'getDecoratedCharacters',
    value: function getDecoratedCharacters(decorations) {
      var node = this;
      var _node = node,
          key = _node.key,
          characters = _node.characters;

      // PERF: Exit early if there are no characters to be decorated.

      if (characters.size == 0) return characters;

      decorations.forEach(function (range) {
        var startKey = range.startKey,
            endKey = range.endKey,
            startOffset = range.startOffset,
            endOffset = range.endOffset,
            marks = range.marks;

        var hasStart = startKey == key;
        var hasEnd = endKey == key;
        var index = hasStart ? startOffset : 0;
        var length = hasEnd ? endOffset - index : characters.size;
        node = node.addMarks(index, length, marks);
      });

      return node.characters;
    }

    /**
     * Get the decorations for the node from a `schema`.
     *
     * @param {Schema} schema
     * @return {Array}
     */

  }, {
    key: 'getDecorations',
    value: function getDecorations(schema) {
      return schema.__getDecorations(this);
    }

    /**
     * Derive the leaves for a list of `characters`.
     *
     * @param {Array|Void} decorations (optional)
     * @return {List<Leaf>}
     */

  }, {
    key: 'getLeaves',
    value: function getLeaves() {
      var decorations = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];

      var characters = this.getDecoratedCharacters(decorations);
      var leaves = [];

      // PERF: cache previous values for faster lookup.
      var prevChar = void 0;
      var prevLeaf = void 0;

      // If there are no characters, return one empty range.
      if (characters.size == 0) {
        leaves.push({});
      }

      // Otherwise, loop the characters and build the leaves...
      else {
          characters.forEach(function (char, i) {
            var marks = char.marks,
                text = char.text;

            // The first one can always just be created.

            if (i == 0) {
              prevChar = char;
              prevLeaf = { text: text, marks: marks };
              leaves.push(prevLeaf);
              return;
            }

            // Otherwise, compare the current and previous marks.
            var prevMarks = prevChar.marks;
            var isSame = (0, _immutable.is)(marks, prevMarks);

            // If the marks are the same, add the text to the previous range.
            if (isSame) {
              prevChar = char;
              prevLeaf.text += text;
              return;
            }

            // Otherwise, create a new range.
            prevChar = char;
            prevLeaf = { text: text, marks: marks };
            leaves.push(prevLeaf);
          }, []);
        }

      // PERF: convert the leaves to immutable objects after iterating.
      leaves = new _immutable.List(leaves.map(function (object) {
        return new _leaf2.default(object);
      }));

      // Return the leaves.
      return leaves;
    }

    /**
     * Get all of the marks on the text.
     *
     * @return {OrderedSet<Mark>}
     */

  }, {
    key: 'getMarks',
    value: function getMarks() {
      var array = this.getMarksAsArray();
      return new _immutable.OrderedSet(array);
    }

    /**
     * Get all of the marks on the text as an array
     *
     * @return {Array}
     */

  }, {
    key: 'getMarksAsArray',
    value: function getMarksAsArray() {
      return this.characters.reduce(function (array, char) {
        return array.concat(char.marks.toArray());
      }, []);
    }

    /**
     * Get the marks on the text at `index`.
     *
     * @param {Number} index
     * @return {Set<Mark>}
     */

  }, {
    key: 'getMarksAtIndex',
    value: function getMarksAtIndex(index) {
      if (index == 0) return _mark2.default.createSet();
      var characters = this.characters;

      var char = characters.get(index - 1);
      if (!char) return _mark2.default.createSet();
      return char.marks;
    }

    /**
     * Get a node by `key`, to parallel other nodes.
     *
     * @param {String} key
     * @return {Node|Null}
     */

  }, {
    key: 'getNode',
    value: function getNode(key) {
      return this.key == key ? this : null;
    }

    /**
     * Check if the node has a node by `key`, to parallel other nodes.
     *
     * @param {String} key
     * @return {Boolean}
     */

  }, {
    key: 'hasNode',
    value: function hasNode(key) {
      return !!this.getNode(key);
    }

    /**
     * Insert `text` at `index`.
     *
     * @param {Numbder} index
     * @param {String} text
     * @param {String} marks (optional)
     * @return {Text}
     */

  }, {
    key: 'insertText',
    value: function insertText(index, text, marks) {
      var characters = this.characters;

      var chars = _character2.default.createList(text.split('').map(function (char) {
        return { text: char, marks: marks };
      }));

      characters = characters.slice(0, index).concat(chars).concat(characters.slice(index));

      return this.set('characters', characters);
    }

    /**
     * Regenerate the node's key.
     *
     * @return {Text}
     */

  }, {
    key: 'regenerateKey',
    value: function regenerateKey() {
      var key = (0, _generateKey2.default)();
      return this.set('key', key);
    }

    /**
     * Remove a `mark` at `index` and `length`.
     *
     * @param {Number} index
     * @param {Number} length
     * @param {Mark} mark
     * @return {Text}
     */

  }, {
    key: 'removeMark',
    value: function removeMark(index, length, mark) {
      var characters = this.characters.map(function (char, i) {
        if (i < index) return char;
        if (i >= index + length) return char;
        var _char2 = char,
            marks = _char2.marks;

        marks = marks.remove(mark);
        char = char.set('marks', marks);
        return char;
      });

      return this.set('characters', characters);
    }

    /**
     * Remove text from the text node at `index` for `length`.
     *
     * @param {Number} index
     * @param {Number} length
     * @return {Text}
     */

  }, {
    key: 'removeText',
    value: function removeText(index, length) {
      var characters = this.characters;

      var start = index;
      var end = index + length;
      characters = characters.filterNot(function (char, i) {
        return start <= i && i < end;
      });
      return this.set('characters', characters);
    }

    /**
     * Return a JSON representation of the text.
     *
     * @param {Object} options
     * @return {Object}
     */

  }, {
    key: 'toJSON',
    value: function toJSON() {
      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      var object = {
        kind: this.kind,
        leaves: this.getLeaves().toArray().map(function (r) {
          return r.toJSON();
        })
      };

      if (options.preserveKeys) {
        object.key = this.key;
      }

      return object;
    }

    /**
     * Alias `toJS`.
     */

  }, {
    key: 'toJS',
    value: function toJS(options) {
      return this.toJSON(options);
    }

    /**
     * Update a `mark` at `index` and `length` with `properties`.
     *
     * @param {Number} index
     * @param {Number} length
     * @param {Mark} mark
     * @param {Object} properties
     * @return {Text}
     */

  }, {
    key: 'updateMark',
    value: function updateMark(index, length, mark, properties) {
      var newMark = mark.merge(properties);

      var characters = this.characters.map(function (char, i) {
        if (i < index) return char;
        if (i >= index + length) return char;
        var _char3 = char,
            marks = _char3.marks;

        if (!marks.has(mark)) return char;
        marks = marks.remove(mark);
        marks = marks.add(newMark);
        char = char.set('marks', marks);
        return char;
      });

      return this.set('characters', characters);
    }

    /**
     * Validate the text node against a `schema`.
     *
     * @param {Schema} schema
     * @return {Object|Void}
     */

  }, {
    key: 'validate',
    value: function validate(schema) {
      return schema.validateNode(this);
    }
  }, {
    key: 'kind',


    /**
     * Get the node's kind.
     *
     * @return {String}
     */

    get: function get() {
      return 'text';
    }

    /**
     * Is the node empty?
     *
     * @return {Boolean}
     */

  }, {
    key: 'isEmpty',
    get: function get() {
      return this.text == '';
    }

    /**
     * Get the concatenated text of the node.
     *
     * @return {String}
     */

  }, {
    key: 'text',
    get: function get() {
      return this.characters.reduce(function (string, char) {
        return string + char.text;
      }, '');
    }
  }], [{
    key: 'create',


    /**
     * Create a new `Text` with `attrs`.
     *
     * @param {Object|Array|List|String|Text} attrs
     * @return {Text}
     */

    value: function create() {
      var attrs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';

      if (Text.isText(attrs)) {
        return attrs;
      }

      if (typeof attrs == 'string') {
        attrs = { leaves: [{ text: attrs }] };
      }

      if ((0, _isPlainObject2.default)(attrs)) {
        if (attrs.text) {
          var _attrs = attrs,
              text = _attrs.text,
              marks = _attrs.marks,
              key = _attrs.key;

          attrs = { key: key, leaves: [{ text: text, marks: marks }] };
        }

        return Text.fromJSON(attrs);
      }

      throw new Error('`Text.create` only accepts objects, arrays, strings or texts, but you passed it: ' + attrs);
    }

    /**
     * Create a list of `Texts` from `elements`.
     *
     * @param {Array<Text|Object>|List<Text|Object>} elements
     * @return {List<Text>}
     */

  }, {
    key: 'createList',
    value: function createList() {
      var elements = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];

      if (_immutable.List.isList(elements) || Array.isArray(elements)) {
        var list = new _immutable.List(elements.map(Text.create));
        return list;
      }

      throw new Error('`Text.createList` only accepts arrays or lists, but you passed it: ' + elements);
    }

    /**
     * Create a `Text` from a JSON `object`.
     *
     * @param {Object|Text} object
     * @return {Text}
     */

  }, {
    key: 'fromJSON',
    value: function fromJSON(object) {
      if (Text.isText(object)) {
        return object;
      }

      var _object$leaves = object.leaves,
          leaves = _object$leaves === undefined ? [] : _object$leaves,
          _object$key = object.key,
          key = _object$key === undefined ? (0, _generateKey2.default)() : _object$key;


      var characters = leaves.map(_leaf2.default.fromJSON).reduce(function (l, r) {
        return l.concat(r.getCharacters());
      }, new _immutable.List());

      var node = new Text({
        characters: characters,
        key: key
      });

      return node;
    }

    /**
     * Alias `fromJS`.
     */

  }, {
    key: 'isText',


    /**
     * Check if `any` is a `Text`.
     *
     * @param {Any} any
     * @return {Boolean}
     */

    value: function isText(any) {
      return !!(any && any[_modelTypes2.default.TEXT]);
    }

    /**
     * Check if `any` is a list of texts.
     *
     * @param {Any} any
     * @return {Boolean}
     */

  }, {
    key: 'isTextList',
    value: function isTextList(any) {
      return _immutable.List.isList(any) && any.every(function (item) {
        return Text.isText(item);
      });
    }
  }]);

  return Text;
}((0, _immutable.Record)(DEFAULTS));

/**
 * Attach a pseudo-symbol for type checking.
 */

Text.fromJS = Text.fromJSON;
Text.prototype[_modelTypes2.default.TEXT] = true;

/**
 * Memoize read methods.
 */

(0, _memoize2.default)(Text.prototype, ['getMarks', 'getMarksAsArray'], {
  takesArguments: false
});

(0, _memoize2.default)(Text.prototype, ['getDecoratedCharacters', 'getDecorations', 'getLeaves', 'getMarksAtIndex', 'validate'], {
  takesArguments: true
});

/**
 * Export.
 *
 * @type {Text}
 */

exports.default = Text;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/models/text.js"],"names":["DEFAULTS","characters","key","undefined","Text","index","length","mark","marks","addMarks","set","map","char","i","union","decorations","node","size","forEach","range","startKey","endKey","startOffset","endOffset","hasStart","hasEnd","schema","__getDecorations","getDecoratedCharacters","leaves","prevChar","prevLeaf","push","text","prevMarks","isSame","object","array","getMarksAsArray","reduce","concat","toArray","createSet","get","getNode","chars","createList","split","slice","remove","start","end","filterNot","options","kind","getLeaves","r","toJSON","preserveKeys","properties","newMark","merge","has","add","validateNode","string","attrs","isText","fromJSON","Error","elements","isList","Array","isArray","list","create","l","getCharacters","any","TEXT","every","item","fromJS","prototype","takesArguments"],"mappings":"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","file":"text.js","sourcesContent":["\nimport isPlainObject from 'is-plain-object'\nimport { List, OrderedSet, Record, Set, is } from 'immutable'\n\nimport Character from './character'\nimport Mark from './mark'\nimport Leaf from './leaf'\nimport MODEL_TYPES from '../constants/model-types'\nimport generateKey from '../utils/generate-key'\nimport memoize from '../utils/memoize'\n\n/**\n * Default properties.\n *\n * @type {Object}\n */\n\nconst DEFAULTS = {\n  characters: new List(),\n  key: undefined,\n}\n\n/**\n * Text.\n *\n * @type {Text}\n */\n\nclass Text extends Record(DEFAULTS) {\n\n  /**\n   * Create a new `Text` with `attrs`.\n   *\n   * @param {Object|Array|List|String|Text} attrs\n   * @return {Text}\n   */\n\n  static create(attrs = '') {\n    if (Text.isText(attrs)) {\n      return attrs\n    }\n\n    if (typeof attrs == 'string') {\n      attrs = { leaves: [{ text: attrs }] }\n    }\n\n    if (isPlainObject(attrs)) {\n      if (attrs.text) {\n        const { text, marks, key } = attrs\n        attrs = { key, leaves: [{ text, marks }] }\n      }\n\n      return Text.fromJSON(attrs)\n    }\n\n    throw new Error(`\\`Text.create\\` only accepts objects, arrays, strings or texts, but you passed it: ${attrs}`)\n  }\n\n  /**\n   * Create a list of `Texts` from `elements`.\n   *\n   * @param {Array<Text|Object>|List<Text|Object>} elements\n   * @return {List<Text>}\n   */\n\n  static createList(elements = []) {\n    if (List.isList(elements) || Array.isArray(elements)) {\n      const list = new List(elements.map(Text.create))\n      return list\n    }\n\n    throw new Error(`\\`Text.createList\\` only accepts arrays or lists, but you passed it: ${elements}`)\n  }\n\n  /**\n   * Create a `Text` from a JSON `object`.\n   *\n   * @param {Object|Text} object\n   * @return {Text}\n   */\n\n  static fromJSON(object) {\n    if (Text.isText(object)) {\n      return object\n    }\n\n    const {\n      leaves = [],\n      key = generateKey(),\n    } = object\n\n    const characters = leaves\n      .map(Leaf.fromJSON)\n      .reduce((l, r) => l.concat(r.getCharacters()), new List())\n\n    const node = new Text({\n      characters,\n      key,\n    })\n\n    return node\n  }\n\n  /**\n   * Alias `fromJS`.\n   */\n\n  static fromJS = Text.fromJSON\n\n  /**\n   * Check if `any` is a `Text`.\n   *\n   * @param {Any} any\n   * @return {Boolean}\n   */\n\n  static isText(any) {\n    return !!(any && any[MODEL_TYPES.TEXT])\n  }\n\n  /**\n   * Check if `any` is a list of texts.\n   *\n   * @param {Any} any\n   * @return {Boolean}\n   */\n\n  static isTextList(any) {\n    return List.isList(any) && any.every(item => Text.isText(item))\n  }\n\n  /**\n   * Get the node's kind.\n   *\n   * @return {String}\n   */\n\n  get kind() {\n    return 'text'\n  }\n\n  /**\n   * Is the node empty?\n   *\n   * @return {Boolean}\n   */\n\n  get isEmpty() {\n    return this.text == ''\n  }\n\n  /**\n   * Get the concatenated text of the node.\n   *\n   * @return {String}\n   */\n\n  get text() {\n    return this.characters.reduce((string, char) => string + char.text, '')\n  }\n\n  /**\n   * Add a `mark` at `index` and `length`.\n   *\n   * @param {Number} index\n   * @param {Number} length\n   * @param {Mark} mark\n   * @return {Text}\n   */\n\n  addMark(index, length, mark) {\n    const marks = new Set([mark])\n    return this.addMarks(index, length, marks)\n  }\n\n  /**\n   * Add a `set` of marks at `index` and `length`.\n   *\n   * @param {Number} index\n   * @param {Number} length\n   * @param {Set<Mark>} set\n   * @return {Text}\n   */\n\n  addMarks(index, length, set) {\n    const characters = this.characters.map((char, i) => {\n      if (i < index) return char\n      if (i >= index + length) return char\n      let { marks } = char\n      marks = marks.union(set)\n      char = char.set('marks', marks)\n      return char\n    })\n\n    return this.set('characters', characters)\n  }\n\n  /**\n   * Derive a set of decorated characters with `decorations`.\n   *\n   * @param {List<Decoration>} decorations\n   * @return {List<Character>}\n   */\n\n  getDecoratedCharacters(decorations) {\n    let node = this\n    const { key, characters } = node\n\n    // PERF: Exit early if there are no characters to be decorated.\n    if (characters.size == 0) return characters\n\n    decorations.forEach((range) => {\n      const { startKey, endKey, startOffset, endOffset, marks } = range\n      const hasStart = startKey == key\n      const hasEnd = endKey == key\n      const index = hasStart ? startOffset : 0\n      const length = hasEnd ? endOffset - index : characters.size\n      node = node.addMarks(index, length, marks)\n    })\n\n    return node.characters\n  }\n\n  /**\n   * Get the decorations for the node from a `schema`.\n   *\n   * @param {Schema} schema\n   * @return {Array}\n   */\n\n  getDecorations(schema) {\n    return schema.__getDecorations(this)\n  }\n\n  /**\n   * Derive the leaves for a list of `characters`.\n   *\n   * @param {Array|Void} decorations (optional)\n   * @return {List<Leaf>}\n   */\n\n  getLeaves(decorations = []) {\n    const characters = this.getDecoratedCharacters(decorations)\n    let leaves = []\n\n    // PERF: cache previous values for faster lookup.\n    let prevChar\n    let prevLeaf\n\n    // If there are no characters, return one empty range.\n    if (characters.size == 0) {\n      leaves.push({})\n    }\n\n    // Otherwise, loop the characters and build the leaves...\n    else {\n      characters.forEach((char, i) => {\n        const { marks, text } = char\n\n        // The first one can always just be created.\n        if (i == 0) {\n          prevChar = char\n          prevLeaf = { text, marks }\n          leaves.push(prevLeaf)\n          return\n        }\n\n        // Otherwise, compare the current and previous marks.\n        const prevMarks = prevChar.marks\n        const isSame = is(marks, prevMarks)\n\n        // If the marks are the same, add the text to the previous range.\n        if (isSame) {\n          prevChar = char\n          prevLeaf.text += text\n          return\n        }\n\n        // Otherwise, create a new range.\n        prevChar = char\n        prevLeaf = { text, marks }\n        leaves.push(prevLeaf)\n      }, [])\n    }\n\n    // PERF: convert the leaves to immutable objects after iterating.\n    leaves = new List(leaves.map(object => new Leaf(object)))\n\n    // Return the leaves.\n    return leaves\n  }\n\n  /**\n   * Get all of the marks on the text.\n   *\n   * @return {OrderedSet<Mark>}\n   */\n\n  getMarks() {\n    const array = this.getMarksAsArray()\n    return new OrderedSet(array)\n  }\n\n  /**\n   * Get all of the marks on the text as an array\n   *\n   * @return {Array}\n   */\n\n  getMarksAsArray() {\n    return this.characters.reduce((array, char) => {\n      return array.concat(char.marks.toArray())\n    }, [])\n  }\n\n  /**\n   * Get the marks on the text at `index`.\n   *\n   * @param {Number} index\n   * @return {Set<Mark>}\n   */\n\n  getMarksAtIndex(index) {\n    if (index == 0) return Mark.createSet()\n    const { characters } = this\n    const char = characters.get(index - 1)\n    if (!char) return Mark.createSet()\n    return char.marks\n  }\n\n  /**\n   * Get a node by `key`, to parallel other nodes.\n   *\n   * @param {String} key\n   * @return {Node|Null}\n   */\n\n  getNode(key) {\n    return this.key == key\n      ? this\n      : null\n  }\n\n  /**\n   * Check if the node has a node by `key`, to parallel other nodes.\n   *\n   * @param {String} key\n   * @return {Boolean}\n   */\n\n  hasNode(key) {\n    return !!this.getNode(key)\n  }\n\n  /**\n   * Insert `text` at `index`.\n   *\n   * @param {Numbder} index\n   * @param {String} text\n   * @param {String} marks (optional)\n   * @return {Text}\n   */\n\n  insertText(index, text, marks) {\n    let { characters } = this\n    const chars = Character.createList(text.split('').map(char => ({ text: char, marks })))\n\n    characters = characters.slice(0, index)\n      .concat(chars)\n      .concat(characters.slice(index))\n\n    return this.set('characters', characters)\n  }\n\n  /**\n   * Regenerate the node's key.\n   *\n   * @return {Text}\n   */\n\n  regenerateKey() {\n    const key = generateKey()\n    return this.set('key', key)\n  }\n\n  /**\n   * Remove a `mark` at `index` and `length`.\n   *\n   * @param {Number} index\n   * @param {Number} length\n   * @param {Mark} mark\n   * @return {Text}\n   */\n\n  removeMark(index, length, mark) {\n    const characters = this.characters.map((char, i) => {\n      if (i < index) return char\n      if (i >= index + length) return char\n      let { marks } = char\n      marks = marks.remove(mark)\n      char = char.set('marks', marks)\n      return char\n    })\n\n    return this.set('characters', characters)\n  }\n\n  /**\n   * Remove text from the text node at `index` for `length`.\n   *\n   * @param {Number} index\n   * @param {Number} length\n   * @return {Text}\n   */\n\n  removeText(index, length) {\n    let { characters } = this\n    const start = index\n    const end = index + length\n    characters = characters.filterNot((char, i) => start <= i && i < end)\n    return this.set('characters', characters)\n  }\n\n  /**\n   * Return a JSON representation of the text.\n   *\n   * @param {Object} options\n   * @return {Object}\n   */\n\n  toJSON(options = {}) {\n    const object = {\n      kind: this.kind,\n      leaves: this.getLeaves().toArray().map(r => r.toJSON()),\n    }\n\n    if (options.preserveKeys) {\n      object.key = this.key\n    }\n\n    return object\n  }\n\n  /**\n   * Alias `toJS`.\n   */\n\n  toJS(options) {\n    return this.toJSON(options)\n  }\n\n  /**\n   * Update a `mark` at `index` and `length` with `properties`.\n   *\n   * @param {Number} index\n   * @param {Number} length\n   * @param {Mark} mark\n   * @param {Object} properties\n   * @return {Text}\n   */\n\n  updateMark(index, length, mark, properties) {\n    const newMark = mark.merge(properties)\n\n    const characters = this.characters.map((char, i) => {\n      if (i < index) return char\n      if (i >= index + length) return char\n      let { marks } = char\n      if (!marks.has(mark)) return char\n      marks = marks.remove(mark)\n      marks = marks.add(newMark)\n      char = char.set('marks', marks)\n      return char\n    })\n\n    return this.set('characters', characters)\n  }\n\n  /**\n   * Validate the text node against a `schema`.\n   *\n   * @param {Schema} schema\n   * @return {Object|Void}\n   */\n\n  validate(schema) {\n    return schema.validateNode(this)\n  }\n\n}\n\n/**\n * Attach a pseudo-symbol for type checking.\n */\n\nText.prototype[MODEL_TYPES.TEXT] = true\n\n/**\n * Memoize read methods.\n */\n\nmemoize(Text.prototype, [\n  'getMarks',\n  'getMarksAsArray',\n], {\n  takesArguments: false,\n})\n\nmemoize(Text.prototype, [\n  'getDecoratedCharacters',\n  'getDecorations',\n  'getLeaves',\n  'getMarksAtIndex',\n  'validate'\n], {\n  takesArguments: true,\n})\n\n/**\n * Export.\n *\n * @type {Text}\n */\n\nexport default Text\n"]}