getFeatures(pixel) {
    if (this.renderedTiles.length === 0) {
      return Promise.resolve([]);
    }
    return new Promise((resolve, reject) => {
      const layer = this.getLayer();
      const source = layer.getSource();
      const projection = this.renderedProjection;
      const projectionExtent = projection.getExtent();
      const resolution = this.renderedResolution;
      const tileGrid = source.getTileGridForProjection(projection);
      const coordinate = applyTransform(
        this.renderedPixelToCoordinateTransform_,
        pixel.slice(),
      );
      const tileCoordString = tileGrid
        .getTileCoordForCoordAndResolution(coordinate, resolution)
        .toString();
      const tile =
        /** @type {Array<import("../../VectorRenderTile.js").default>} */ (
          this.renderedTiles
        ).find(
          (tile) =>
            tile.tileCoord.toString() === tileCoordString &&
            tile.getState() === TileState.LOADED,
        );
      if (!tile || tile.loadingSourceTiles > 0) {
        resolve([]);
        return;
      }
      if (
        source.getWrapX() &&
        projection.canWrapX() &&
        !containsExtent(
          projectionExtent,
          tileGrid.getTileCoordExtent(tile.tileCoord),
        )
      ) {
        wrapX(coordinate, projection);
      }
      const layerUid = getUid(layer);
      const extent = tileGrid.getTileCoordExtent(tile.wrappedTileCoord);
      const corner = getTopLeft(extent);
      const tilePixel = [
        (coordinate[0] - corner[0]) / resolution,
        (corner[1] - coordinate[1]) / resolution,
      ];
      const features = tile
        .getSourceTiles()
        .reduce(
          (accumulator, sourceTile) =>
            accumulator.concat(sourceTile.getFeatures()),
          /** @type {Array<import("../../Feature.js").FeatureLike>} */ ([]),
        );
      let hitDetectionImageData = tile.hitDetectionImageData[layerUid];
      if (!hitDetectionImageData) {
        const tileSize = toSize(
          tileGrid.getTileSize(
            tileGrid.getZForResolution(resolution, source.zDirection),
          ),
        );
        const rotation = this.renderedRotation_;
        const transforms = [
          this.getRenderTransform(
            tileGrid.getTileCoordCenter(tile.wrappedTileCoord),
            resolution,
            0,
            HIT_DETECT_RESOLUTION,
            tileSize[0] * HIT_DETECT_RESOLUTION,
            tileSize[1] * HIT_DETECT_RESOLUTION,
            0,
          ),
        ];
        hitDetectionImageData = createHitDetectionImageData(
          tileSize,
          transforms,
          features,
          layer.getStyleFunction(),
          tileGrid.getTileCoordExtent(tile.wrappedTileCoord),
          tile.getReplayState(layer).renderedResolution,
          rotation,
        );
        tile.hitDetectionImageData[layerUid] = hitDetectionImageData;
      }
      resolve(hitDetect(tilePixel, features, hitDetectionImageData));
    });
  }
Asynchronous layer level hit detection.
@param {import("../../pixel.js").Pixel} pixel Pixel.
@return {Promise<Array<import("../../Feature.js").FeatureLike>>} Promise that resolves with an array of features.
@override