How to use the lib0/error.js.unexpectedCase function in lib0

export const writeRelativePosition = (encoder, rpos) => {
  const { type, tname, item } = rpos
  if (item !== null) {
    encoding.writeVarUint(encoder, 0)
    writeID(encoder, item)
  } else if (tname !== null) {
    // case 2: found position at the end of the list and type is stored in y.share
    encoding.writeUint8(encoder, 1)
    encoding.writeVarString(encoder, tname)
  } else if (type !== null) {
    // case 3: found position at the end of the list and type is attached to an item
    encoding.writeUint8(encoder, 2)
    writeID(encoder, type)
  } else {
    throw error.unexpectedCase()
  }
  return encoder
}

  () => { throw error.unexpectedCase() }, // GC is not ItemContent
  readContentDeleted,

while (left <= right) {
    const midindex = math.floor((left + right) / 2)
    const mid = structs[midindex]
    const midclock = mid.id.clock
    if (midclock <= clock) {
      if (clock < midclock + mid.length) {
        return midindex
      }
      left = midindex + 1
    } else {
      right = midindex - 1
    }
  }
  // Always check state before looking for a struct in StructStore
  // Therefore the case of not finding a struct is unexpected
  throw error.unexpectedCase()
}

export const findRootTypeKey = type => {
  // @ts-ignore _y must be defined, otherwise unexpected case
  for (let [key, value] of type.doc.share) {
    if (value === type) {
      return key
    }
  }
  throw error.unexpectedCase()
}

parent = /** @type {ContentType} */ (parentItem.content).type
      }
    } else if (this.parentYKey !== null) {
      parent = transaction.doc.get(this.parentYKey)
    } else if (left !== null) {
      if (left.constructor !== GC) {
        parent = left.parent
        parentSub = left.parentSub
      }
    } else if (right !== null) {
      if (right.constructor !== GC) {
        parent = right.parent
        parentSub = right.parentSub
      }
    } else {
      throw error.unexpectedCase()
    }

    return parent === null
      ? new GC(this.id, this.length)
      : new Item(
        this.id,
        left,
        this.left,
        right,
        this.right,
        parent,
        parentSub,
        this.content
      )
  }
}

gc (store, parentGCd) {
    if (!this.deleted) {
      throw error.unexpectedCase()
    }
    this.content.gc(store)
    if (parentGCd) {
      replaceStruct(store, this, new GC(this.id, this.length))
    } else {
      this.content = new ContentDeleted(this.length)
    }
  }

if (type._length === apos.offset) {
    return createRelativePosition(type, null)
  } else {
    let offset = apos.offset
    let n = type._start
    while (n !== null) {
      if (!n.deleted && n.countable) {
        if (n.length > offset) {
          return createRelativePosition(type, ID.createID(n.id.client, n.id.clock + offset))
        }
        offset -= n.length
      }
      n = n.right
    }
  }
  throw error.unexpectedCase()
}