While looking into an issue with slow text extraction with a large OCR-ed PDF, I saw in Chrome's profiler that there appeared to be a lot of overhead from calls to `postMessage`.

PDF.js extracts a total of ~500,000 text items from the attached 590-page PDF. When extracting text (eg. using the search function) these text items get sent from the worker thread to the main thread in a series of ~200,000 `postMessage` calls. I checked this by adding a `message` event listener to the `Worker` instance. I then tried modifying `src/core/evaluator.js` to comment out the most frequent `enqueueChunk()` call so that it would flush items in larger batches and thus send the same data with fewer cross-thread messages. It seems to make a substantial difference in Chrome.

I'd be happy to send a PR to fix this, but I'm not sure what the best/cleanest way is to resolve this. The smallest change I can think of would be to modify the `next` callback below so that it invokes `enqueueChunk` only once every N calls. Would that break anything? Should the problem be fixed at a higher level?

## Steps to reproduce

Attach (recommended) or Link to PDF file here: [leviathan.pdf](https://github.com/mozilla/pdf.js/files/7100224/leviathan.pdf)

Configuration:
- Web browser and its version: 95.0.4621.4
- Operating system and its version: macOS 11
- PDF.js version: 0a366dda6a174292e6d109df526f835bfabf87a8
- Is a browser extension: No

Open the attached PDF in PDF.js's development server and search for the phrase "for such truth", which occurs near the very end of the document.

On my 2020 Intel MacBook Pro, testing in Chrome 95, PDF.js takes ~15 seconds to find a match.

Now apply the following diff, then reload the viewer and retry the search:

```diff
diff --git a/src/core/evaluator.js b/src/core/evaluator.js
index 90615b228..85d6325a9 100644
--- a/src/core/evaluator.js
+++ b/src/core/evaluator.js
@@ -2669,7 +2669,8 @@ class PartialEvaluator {
 
     return new Promise(function promiseBody(resolve, reject) {
       const next = function (promise) {
-        enqueueChunk();
+        // TESTING
+        // enqueueChunk();
         Promise.all([promise, sink.ready]).then(function () {
           try {
             promiseBody(resolve, reject);
```

With the above diff applied, the search returns the same result but is much faster (~3-4 seconds).

One quirk I noticed is that initial search speed is much slower (~20 seconds) if Chrome's devtools are open when the search happens. This applies with or without the above diff.

fntCapablty.relve(
          new TranlatedFnt({
            ladedName: fnt.ladedName,
            fnt: new ErrrFnt(
              rean ntancef Errr ? rean.meage : rean
            ),
            dct: fnt,
            evaluatrOptn: th.ptn,
          })
        );
      });
    return fntCapablty.prme;
  }
  buldPath(peratrLt, fn, arg, parngText = fale) {
    cnt latIndex = peratrLt.length - 1;
    f (!arg) {
      arg = [];
    }
    f (
      latIndex < 0 ||
      peratrLt.fnArray[latIndex] !== OPS.cntructPath
    ) {
      
      
      
      
      
      
      
      f (parngText) {