**
 * @param {Array<AbstractStruct>} structs
 * @param {number} pos
 */
const tryToMergeWithLeft = (structs, pos) => {
  const left = structs[pos - 1]
  const right = structs[pos]
  if (left.deleted === right.deleted && left.constructor === right.constructor) {
    if (left.mergeWith(right)) {
      if (right instanceof Item && right.parentSub !== null && /** @type {AbstractType<any>} */ (right.parent)._map.get(right.parentSub) === right) {
        /** @type {AbstractType<any>} */ (right.parent)._map.set(right.parentSub, /** @type {Item} */ (left))
      }
      return true;
    }
  }
  return false;
}

const tryToMergeWithLeftProvider = () => {
  /**
   * @type {Array<number[]>}
   */
  const spliceRanges = []
  spliceRanges.push([0])
  return {
    /**
     * @param {Array<AbstractStruct>} structs
     * @param {number} pos
     */
    exec: (structs, pos) => {
      const needsSplice = tryToMergeWithLeft(structs, pos)
      const spliceRange = spliceRanges[spliceRanges.length - 1]
      if(needsSplice) {
        spliceRange[1] = pos
        spliceRange[0]++
      } else if (spliceRange.length === 2) {
        // @ts-ignore
        spliceRange.push([0]);
      }
    },
    /**
     * @param {Array<AbstractStruct>} structs
     */
    flush: (structs) => {
      for (const spliceRange of spliceRanges) {
        if (spliceRange.length === 2) {
          structs.splice(spliceRange[1], spliceRange[0])
        }
      }
    }
  };

const tryMergeDeleteSet = (ds, store) => {
  // try to merge deleted / gc'd items
  // merge from right to left for better efficiecy and so we don't miss any merge targets
  ds.clients.forEach((deleteItems, client) => {
    const structs = /** @type {Array<GC|Item>} */ (store.clients.get(client))
    for (let di = deleteItems.length - 1; di >= 0; di--) {
      const deleteItem = deleteItems[di]
      // start with merging the item next to the last deleted item
      const mostRightIndexToCheck = math.min(structs.length - 1, 1 + findIndexSS(structs, deleteItem.clock + deleteItem.len - 1))
      const mergeLeftProvider = tryToMergeWithLeftProvider()
      for (
        let si = mostRightIndexToCheck, struct = structs[si];
        si > 0 && struct.id.clock >= deleteItem.clock;
        struct = structs[--si]
      ) {
        mergeLeftProvider.exec(structs, si)  // TRACK THE CHANGES HERE WITH THE WRAPPED FUNCTIONS
      }
     mergeLeftProvider.flush(structs, si) // APPLY THEM IN BULK HERE AFTER THE LOOP
    }
  })
}