Fix "Maximum call stack size exceeded" bug

[adamwathan]

For performance reasons we already read the content line by line, this allows us to cache individual lines if we already saw them. This also allows us to do the necessary work on relatively "small" content chunks because not a lot of developers use very long lines in the source files.

However...

Some people either misconfigure the content paths to include everything (even node_modules) or in a more realistic scenario link to a 3rd party dependency that uses Tailwind inside the node_modules folder. Those files are typically minified, all on one line. The stack size issue occurs when we try to push a lot of matches into an array. We used result.push(...x) which is limited by the length of x because functions have a maximum amount of parameters they can receive.

Thanks to @nam-tran-tego for the wonderful reproduction and fix for this!

Fixes: #8582

[MichaelAllenWarner]

I don't really know the context here, but if performance is at all relevant, then you might consider doing something like this instead:

for (let pattern of patterns) {
  for (let result of (content.match(pattern) || [])) {
    results.push(result);
  }
}

(didn't test it or anything, so apologies if that isn't quite right, but the point is that there's no need to iterate through results on every iteration of patterns; same principle as in this piece: https://betterprogramming.pub/the-reduce-spread-anti-pattern-fc0c1c0b23f6)

[thecrypticace]

I looked into this a bit and there's very little perf difference (in a plain program at least) when given a super large content array. There's a slight difference in heap allocations but it's tiny. The perf difference is on the order of ± 0.1ms for 1000 iterations.

Though, my testing method could be a bit flawed or V8 may have hyper optimized my test case. Either way I think it's not a big deal one way or the other.

[MichaelAllenWarner]

Huh. I'd be surprised if there's really no significant difference, since pushing only the new items each time is O(n), whereas also iterating through all previously added items each time is O(n^2-ish). But yeah, could be that they've optimized it. Cheers.

[thecrypticace]

This is because array's in V8 are likely tail-allocated. This means doing something like result = [...result, ...anything] makes only a constant number of allocations independent of the number of items in result. Only the number of items in anything matters. If you flip the arrays around (result = [...anything, ...result]) it can't reuse existing memory/storage and must copy memory around. If you try this it results in times that are almost 4x slower.

[MichaelAllenWarner]

Yes, you must be right. Good info!