constructor(id, left, origin, right, rightOrigin, parent, parentSub, content) {
    super(id, content.getLength());
    /**
     * The item that was originally to the left of this item.
     * @type {ID | null}
     */

    this.origin = origin;
    /**
     * The item that is currently to the left of this item.
     * @type {Item | null}
     */

    this.left = left;
    /**
     * The item that is currently to the right of this item.
     * @type {Item | null}
     */

    this.right = right;
    /**
     * The item that was originally to the right of this item.
     * @type {ID | null}
     */

    this.rightOrigin = rightOrigin;
    /**
     * @type {AbstractType<any>|ID|null}
     */

    this.parent = parent;
    /**
     * If the parent refers to this item with some kind of key (e.g. YMap, the
     * key is specified here. The key is then used to refer to the list in which
     * to insert this item. If `parentSub = null` type._start is the list in
     * which to insert to. Otherwise it is `parent._map`.
     * @type {String | null}
     */

    this.parentSub = parentSub;
    /**
     * If this type's effect is reundone this type refers to the type that undid
     * this operation.
     * @type {ID | null}
     */

    this.redone = null;
    /**
     * @type {AbstractContent}
     */

    this.content = content;
    /**
     * bit1: keep
     * bit2: countable
     * bit3: deleted
     * bit4: mark - mark node as fast-search-marker
     * @type {number} byte
     */

    this.info = this.content.isCountable() ? binary.BIT2 : 0;
  }
@param {ID} id
@param {Item | null} left
@param {ID | null} origin
@param {Item | null} right
@param {ID | null} rightOrigin
@param {AbstractType<any>|ID|null} parent Is a type if integrated, is null if it is possible to copy parent from left or right, is ID before integration to search for it.
@param {string | null} parentSub
@param {AbstractContent} content