function sparseFillEmptyRows_(indices, values, denseShape, defaultValue) {
    const $indices = (0, _tensorUtilEnv.convertToTensor)(indices, "indices", "sparseFillEmptyRows", "int32");
    const $values = (0, _tensorUtilEnv.convertToTensor)(values, "values", "sparseFillEmptyRows");
    const $denseShape = (0, _tensorUtilEnv.convertToTensor)(denseShape, "denseShape", "sparseFillEmptyRows", "int32");
    const $defaultValue = (0, _tensorUtilEnv.convertToTensor)(defaultValue, "defaultValue", "sparseFillEmptyRows", $values.dtype);
    if ($indices.rank !== 2) throw new Error(`Indices should be Tensor2D but received shape
        ${$indices.shape}`);
    if ($values.rank !== 1) throw new Error(`Values should be Tensor1D but received shape ${$values.shape}`);
    if ($denseShape.rank !== 1) throw new Error(`Dense shape should be Tensor1D but received shape ${$denseShape.shape}`);
    if ($defaultValue.rank !== 0) throw new Error(`Default value should be a scalar but received shape ${$defaultValue.shape}`);
    const inputs = {
        indices: $indices,
        values: $values,
        denseShape: $denseShape,
        defaultValue: $defaultValue
    };
    const result = (0, _engine.ENGINE).runKernel((0, _kernelNames.SparseFillEmptyRows), inputs);
    return {
        outputIndices: result[0],
        outputValues: result[1],
        emptyRowIndicator: result[2],
        reverseIndexMap: result[3]
    };
}
The input SparseTensor is represented via the map of inputs {`indices`,
`values`, `denseShape`}. The output SparseTensor has the same `denseShape`
but with indices `outputIndices` and values `outputValues`. This op inserts a
single entry for every row that doesn't have any values. The index is created
as `[row, 0, ..., 0]` and the inserted value is `defaultValue`.

For example, suppose `spInput` has shape [5, 6] and non-empty values:
[0, 1]: a
[0, 3]: b
[2, 0]: c
[3, 1]: d

Rows 1 and 4 are empty, so the output will be of shape [5, 6] with values:
[0, 1]: a
[0, 3]: b
[1, 0]: `defaultValue`
[2, 0]: c
[3, 1]: d
[4, 0]: `defaultValue`

The output SparseTensor will be in row-major order and will have the same
shape as the input.

This op also returns an indicator vector shaped [dense_shape[0]] such that
emptyRowIndicator[i] = True iff row i was an empty row.

And a reverse index map vector shaped [indices.shape[0]] that is used during
backpropagation, reverseIndexMap[i] = outi s.t. indices[i, j] ==
outputIndices[outi, j] for all j

```js
const result = tf.sparse.sparseFillEmptyRows(
  [[0, 0], [1, 0], [1, 3], [1, 4], [3, 2], [3, 3]],
  [0, 10, 13, 14, 32, 33], [5, 6], -1);
console.log(result);
result['outputIndices'].print(); // [[0, 0], [1, 0], [1, 3], [1, 4],
                                 //  [2, 0], [3, 2], [3, 3], [4, 0]]
result['outputValues'].print(); // [0, 10, 13, 14,-1, 32, 33, -1]
result['emptyRowIndicator'].print(); // [false, false, true, false, true]
result['reverseIndexMap'].print(); // [0, 1, 2, 3, 5, 6]
```
@param indices: 2-D. The indices of the sparse tensor.
@param values: 1-D. The values of the sparse tensor.
@param denseShape: 1-D. The shape of the sparse tensor.
@param defaultValue: 0-D. Default value to insert into location [row, 0, ...,
    0] for rows missing from the input sparse tensor.
@return A map with the following properties:
    - outputIndices
    - outputValues: 1-D. The values of the filled sparse tensor.
    - emptyRowIndicator: 1-D. Whether the dense row was missing in the input
sparse tensor.
    - reverseIndexMap: 1-D. A map from the input indices to the output
indices.
@doc {heading: 'Operations', subheading: 'Sparse'}