How to use the webworker-promise function in webworker-promise

if (webWorkerUrl.startsWith('http')) {
    return axios.get(webWorkerUrl, {
      responseType: 'blob'
    }).then(function (response) {
      var worker = new window.Worker(URL.createObjectURL(response.data) // eslint-disable-line
      );
      var webworkerPromise = new WebworkerPromise(worker);
      return {
        webworkerPromise: webworkerPromise,
        worker: worker
      };
    });
  }

  var worker = new window.Worker(webWorkerUrl);
  var webworkerPromise = new WebworkerPromise(worker);
  return Promise.resolve({
    webworkerPromise: webworkerPromise,
    worker: worker
  });
};

}).then(function (response) {
      var worker = new window.Worker(URL.createObjectURL(response.data) // eslint-disable-line
      );
      var webworkerPromise = new WebworkerPromise(worker);
      return {
        webworkerPromise: webworkerPromise,
        worker: worker
      };
    });
  }

var createWebworkerPromise = function createWebworkerPromise(name, existingWorker) {
  if (existingWorker) {
    var _webworkerPromise = new WebworkerPromise(existingWorker);

    return Promise.resolve({
      webworkerPromise: _webworkerPromise,
      worker: existingWorker
    });
  }

  var webWorkerUrl = "".concat(config.itkModulesPath, "/WebWorkers/").concat(name, ".worker.js");

  if (webWorkerUrl.startsWith('http')) {
    return axios.get(webWorkerUrl, {
      responseType: 'blob'
    }).then(function (response) {
      var worker = new window.Worker(URL.createObjectURL(response.data) // eslint-disable-line
      );
      var webworkerPromise = new WebworkerPromise(worker);

reformattedGradients
        );

        publicAPI.deactivate();
        return true;
      };
    }

    const maxNumberOfWorkers = 4;
    const depthStride = Math.ceil(depth / maxNumberOfWorkers);
    const workerPromises = [];
    const workers = [];
    let depthIndex = 0;
    while (depthIndex < depth - 1) {
      const worker = new ComputeGradientsWorker();
      const workerPromise = new WebworkerPromise(worker);
      const depthStart = depthIndex;
      let depthEnd = depthIndex + depthStride; // no -1 to include one more slice to compute gradient
      depthEnd = Math.min(depthEnd, depth - 1);
      const subData = new data.constructor(
        data.slice(depthStart * width * height, (depthEnd + 1) * width * height) // +1 to include data from slice at depthEnd
      );
      workers.push(worker);
      workerPromises.push(
        workerPromise.postMessage(
          {
            width,
            height,
            depth,
            spacing,
            data: subData,
            haveWebgl2,

numberOfBinToConsider = 1,
    numberOfBinsToSkip = 1
  ) => {
    model.histogram = null;
    model.histogramArray = array;
    const max = vtkMath.arrayMax(array);
    const min = vtkMath.arrayMin(array);
    model.dataRange = [min, max];

    const maxNumberOfWorkers = 4;
    const arrayStride = Math.floor(array.length / maxNumberOfWorkers) || 1;
    let arrayIndex = 0;
    const workers = [];
    while (arrayIndex < array.length) {
      const worker = new ComputeHistogramWorker();
      const workerPromise = new WebworkerPromise(worker);
      const arrayStart = arrayIndex;
      const arrayEnd = Math.min(arrayIndex + arrayStride, array.length - 1);
      const subArray = new array.constructor(
        array.slice(arrayStart, arrayEnd + 1)
      );
      workers.push(
        workerPromise.postMessage(
          { array: subArray, min, max, numberOfBins: model.numberOfBins },
          [subArray.buffer]
        )
      );
      arrayIndex += arrayStride;
    }
    Promise.all(workers).then((workerResults) => {
      model.histogram = new Float32Array(model.numberOfBins);
      model.histogram.fill(0);

publicAPI.startStroke = () => {
    if (model.labelMap) {
      worker = new PaintFilterWorker();
      workerPromise = new WebworkerPromise(worker);
      workerPromise.exec('start', {
        bufferType: 'Uint8Array',
        dimensions: model.labelMap.getDimensions(),
      });
    }
  };