Как можно вынести выполнение скрипта в отдельный поток?

// main.js
const worker = new Worker('worker.js');

// Отправка данных в worker
worker.postMessage({ type: 'process', data: largeArray });

// Получение результатов
worker.onmessage = (event) => {
  console.log('Result from worker:', event.data);
};

// Обработка ошибок
worker.onerror = (error) => {
  console.error('Worker error:', error);
};

// Обработка сообщений из основного потока
self.onmessage = function(event) {
  const { type, data } = event.data;
  
  if (type === 'process') {
    // Тяжелые вычисления
    const result = heavyComputation(data);
    
    // Отправка результата обратно
    self.postMessage(result);
  }
};

function heavyComputation(data) {
  // Вычисления, которые не блокируют основной поток
  return data.map(item => item * 2);
}

// Регистрация service worker
if ('serviceWorker' in navigator) {
  navigator.serviceWorker.register('/sw.js')
    .then(registration => {
      console.log('Service Worker registered');
    });
}

// sw.js - кэширование и фоновые задачи
self.addEventListener('fetch', (event) => {
  event.respondWith(
    caches.match(event.request)
      .then(response => response || fetch(event.request))
  );
});

const { Worker } = require('worker_threads');

function runService(workerData) {
  return new Promise((resolve, reject) => {
    const worker = new Worker('./worker.js', { workerData });
    worker.on('message', resolve);
    worker.on('error', reject);
    worker.on('exit', (code) => {
      if (code !== 0) {
        reject(new Error(`Worker stopped with exit code ${code}`));
      }
    });
  });
}

// worker.js
const { workerData, parentPort } = require('worker_threads');
parentPort.postMessage(heavyComputation(workerData));

function processInChunks(array, chunkSize, callback) {
  let index = 0;

  function processChunk() {
    const chunk = array.slice(index, index + chunkSize);
    
    // Обработка чанка
    chunk.forEach(processItem);
    
    index += chunkSize;
    
    if (index < array.length) {
      // Продолжаем в следующем frame
      setTimeout(processChunk, 0);
    } else {
      callback();
    }
  }
  
  processChunk();
}

function processDuringIdleTime(tasks) {
  function processTask(deadline) {
    while (tasks.length > 0 && deadline.timeRemaining() > 0) {
      const task = tasks.shift();
      executeTask(task);
    }

    if (tasks.length > 0) {
      requestIdleCallback(processTask);
    }
  }

  requestIdleCallback(processTask);
}

// Рендеринг canvas в worker
const offscreen = canvas.transferControlToOffscreen();
const worker = new Worker('canvas-worker.js');

worker.postMessage({ canvas: offscreen }, [offscreen]);

// canvas-worker.js
self.onmessage = function(event) {
  const canvas = event.data.canvas;
  const ctx = canvas.getContext('2d');
  
  // Рендеринг без блокировки основного потока
  ctx.fillStyle = 'red';
  ctx.fillRect(0, 0, canvas.width, canvas.height);
};